33195 lines
758 KiB
OpenEdge ABL
33195 lines
758 KiB
OpenEdge ABL
# 1 "test.cpp"
|
|
# 1 "<built-in>"
|
|
# 1 "<command-line>"
|
|
# 1 "/usr/include/stdc-predef.h" 1 3 4
|
|
# 1 "<command-line>" 2
|
|
# 1 "test.cpp"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/iostream" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/iostream" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/iostream" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 1 3
|
|
|
|
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 4 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
|
|
# 1855 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 3
|
|
namespace std
|
|
{
|
|
typedef long unsigned int size_t;
|
|
typedef long int ptrdiff_t;
|
|
|
|
|
|
|
|
|
|
}
|
|
# 2097 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 3
|
|
# 1 "/usr/include/features.h" 1 3 4
|
|
# 375 "/usr/include/features.h" 3 4
|
|
# 1 "/usr/include/sys/cdefs.h" 1 3 4
|
|
# 392 "/usr/include/sys/cdefs.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 393 "/usr/include/sys/cdefs.h" 2 3 4
|
|
# 376 "/usr/include/features.h" 2 3 4
|
|
# 399 "/usr/include/features.h" 3 4
|
|
# 1 "/usr/include/gnu/stubs.h" 1 3 4
|
|
# 10 "/usr/include/gnu/stubs.h" 3 4
|
|
# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
|
|
# 11 "/usr/include/gnu/stubs.h" 2 3 4
|
|
# 400 "/usr/include/features.h" 2 3 4
|
|
# 40 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 2 3
|
|
# 2098 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
|
|
# 2101 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
|
|
# 39 "/usr/include/c++/4.8.2/iostream" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/ostream" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/ostream" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/ostream" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/ios" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/ios" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/ios" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/iosfwd" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/iosfwd" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/iosfwd" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stringfwd.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/stringfwd.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/stringfwd.h" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 1 3
|
|
# 46 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
|
|
|
|
# 47 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 63 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
|
|
template<typename>
|
|
class allocator;
|
|
|
|
template<>
|
|
class allocator<void>;
|
|
|
|
|
|
template<typename, typename>
|
|
struct uses_allocator;
|
|
|
|
|
|
|
|
|
|
}
|
|
# 41 "/usr/include/c++/4.8.2/bits/stringfwd.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<class _CharT>
|
|
struct char_traits;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT>,
|
|
typename _Alloc = allocator<_CharT> >
|
|
class basic_string;
|
|
|
|
template<> struct char_traits<char>;
|
|
|
|
|
|
typedef basic_string<char> string;
|
|
|
|
|
|
template<> struct char_traits<wchar_t>;
|
|
|
|
|
|
typedef basic_string<wchar_t> wstring;
|
|
# 86 "/usr/include/c++/4.8.2/bits/stringfwd.h" 3
|
|
|
|
}
|
|
# 40 "/usr/include/c++/4.8.2/iosfwd" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/postypes.h" 1 3
|
|
# 38 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
|
|
# 39 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/cwchar" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/cwchar" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/cwchar" 3
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/wchar.h" 1 3 4
|
|
# 36 "/usr/include/wchar.h" 3 4
|
|
# 1 "/usr/include/stdio.h" 1 3 4
|
|
# 44 "/usr/include/stdio.h" 3 4
|
|
struct _IO_FILE;
|
|
|
|
|
|
|
|
typedef struct _IO_FILE FILE;
|
|
|
|
|
|
|
|
|
|
|
|
# 64 "/usr/include/stdio.h" 3 4
|
|
typedef struct _IO_FILE __FILE;
|
|
# 37 "/usr/include/wchar.h" 2 3 4
|
|
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdarg.h" 1 3 4
|
|
# 40 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdarg.h" 3 4
|
|
typedef __builtin_va_list __gnuc_va_list;
|
|
# 40 "/usr/include/wchar.h" 2 3 4
|
|
|
|
# 1 "/usr/include/bits/wchar.h" 1 3 4
|
|
# 22 "/usr/include/bits/wchar.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 23 "/usr/include/bits/wchar.h" 2 3 4
|
|
# 42 "/usr/include/wchar.h" 2 3 4
|
|
# 51 "/usr/include/wchar.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 212 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 3 4
|
|
typedef long unsigned int size_t;
|
|
# 353 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 3 4
|
|
typedef unsigned int wint_t;
|
|
# 52 "/usr/include/wchar.h" 2 3 4
|
|
# 82 "/usr/include/wchar.h" 3 4
|
|
typedef struct
|
|
{
|
|
int __count;
|
|
union
|
|
{
|
|
|
|
unsigned int __wch;
|
|
|
|
|
|
|
|
char __wchb[4];
|
|
} __value;
|
|
} __mbstate_t;
|
|
# 104 "/usr/include/wchar.h" 3 4
|
|
|
|
|
|
typedef __mbstate_t mbstate_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 132 "/usr/include/wchar.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
struct tm;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
|
|
const wchar_t *__restrict __src) throw ();
|
|
|
|
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
|
|
const wchar_t *__restrict __src, size_t __n)
|
|
throw ();
|
|
|
|
|
|
extern wchar_t *wcscat (wchar_t *__restrict __dest,
|
|
const wchar_t *__restrict __src) throw ();
|
|
|
|
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
|
|
const wchar_t *__restrict __src, size_t __n)
|
|
throw ();
|
|
|
|
|
|
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
|
|
|
|
|
|
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
|
|
size_t __n) throw ();
|
|
|
|
|
|
|
|
# 1 "/usr/include/xlocale.h" 1 3 4
|
|
# 27 "/usr/include/xlocale.h" 3 4
|
|
typedef struct __locale_struct
|
|
{
|
|
|
|
struct __locale_data *__locales[13];
|
|
|
|
|
|
const unsigned short int *__ctype_b;
|
|
const int *__ctype_tolower;
|
|
const int *__ctype_toupper;
|
|
|
|
|
|
const char *__names[13];
|
|
} *__locale_t;
|
|
|
|
|
|
typedef __locale_t locale_t;
|
|
# 181 "/usr/include/wchar.h" 2 3 4
|
|
|
|
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
|
|
__locale_t __loc) throw ();
|
|
|
|
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
|
|
size_t __n, __locale_t __loc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
|
|
|
|
|
|
|
|
extern size_t wcsxfrm (wchar_t *__restrict __s1,
|
|
const wchar_t *__restrict __s2, size_t __n) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
|
|
__locale_t __loc) throw ();
|
|
|
|
|
|
|
|
|
|
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
|
|
size_t __n, __locale_t __loc) throw ();
|
|
|
|
|
|
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
|
|
throw () __asm ("wcschr") __attribute__ ((__pure__));
|
|
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
|
|
throw () __asm ("wcschr") __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
|
|
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
|
|
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
|
|
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
|
|
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
|
|
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
|
|
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
|
|
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
|
|
const wchar_t *__accept)
|
|
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
|
|
throw () __asm ("wcsstr") __attribute__ ((__pure__));
|
|
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
|
|
const wchar_t *__needle)
|
|
throw () __asm ("wcsstr") __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wchar_t *wcstok (wchar_t *__restrict __s,
|
|
const wchar_t *__restrict __delim,
|
|
wchar_t **__restrict __ptr) throw ();
|
|
|
|
|
|
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
|
|
throw () __asm ("wcswcs") __attribute__ ((__pure__));
|
|
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
|
|
const wchar_t *__needle)
|
|
throw () __asm ("wcswcs") __attribute__ ((__pure__));
|
|
# 306 "/usr/include/wchar.h" 3 4
|
|
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
|
|
throw () __asm ("wmemchr") __attribute__ ((__pure__));
|
|
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
|
|
size_t __n)
|
|
throw () __asm ("wmemchr") __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
|
|
throw () __attribute__ ((__pure__));
|
|
|
|
|
|
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
|
|
const wchar_t *__restrict __s2, size_t __n) throw ();
|
|
|
|
|
|
|
|
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
|
|
throw ();
|
|
|
|
|
|
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
|
|
const wchar_t *__restrict __s2, size_t __n)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t btowc (int __c) throw ();
|
|
|
|
|
|
|
|
extern int wctob (wint_t __c) throw ();
|
|
|
|
|
|
|
|
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
|
|
|
|
|
|
|
|
extern size_t mbrtowc (wchar_t *__restrict __pwc,
|
|
const char *__restrict __s, size_t __n,
|
|
mbstate_t *__restrict __p) throw ();
|
|
|
|
|
|
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
|
|
mbstate_t *__restrict __ps) throw ();
|
|
|
|
|
|
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
|
|
mbstate_t *__restrict __ps) throw ();
|
|
extern size_t mbrlen (const char *__restrict __s, size_t __n,
|
|
mbstate_t *__restrict __ps) throw ();
|
|
|
|
# 405 "/usr/include/wchar.h" 3 4
|
|
|
|
|
|
|
|
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
|
|
const char **__restrict __src, size_t __len,
|
|
mbstate_t *__restrict __ps) throw ();
|
|
|
|
|
|
|
|
extern size_t wcsrtombs (char *__restrict __dst,
|
|
const wchar_t **__restrict __src, size_t __len,
|
|
mbstate_t *__restrict __ps) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
|
|
const char **__restrict __src, size_t __nmc,
|
|
size_t __len, mbstate_t *__restrict __ps) throw ();
|
|
|
|
|
|
|
|
extern size_t wcsnrtombs (char *__restrict __dst,
|
|
const wchar_t **__restrict __src,
|
|
size_t __nwc, size_t __len,
|
|
mbstate_t *__restrict __ps) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int wcwidth (wchar_t __c) throw ();
|
|
|
|
|
|
|
|
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern double wcstod (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern float wcstof (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr) throw ();
|
|
extern long double wcstold (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern long int wcstol (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, int __base) throw ();
|
|
|
|
|
|
|
|
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, int __base)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__extension__
|
|
extern long long int wcstoll (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, int __base)
|
|
throw ();
|
|
|
|
|
|
|
|
__extension__
|
|
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr,
|
|
int __base) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__extension__
|
|
extern long long int wcstoq (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, int __base)
|
|
throw ();
|
|
|
|
|
|
|
|
__extension__
|
|
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr,
|
|
int __base) throw ();
|
|
# 530 "/usr/include/wchar.h" 3 4
|
|
extern long int wcstol_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, int __base,
|
|
__locale_t __loc) throw ();
|
|
|
|
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr,
|
|
int __base, __locale_t __loc) throw ();
|
|
|
|
__extension__
|
|
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr,
|
|
int __base, __locale_t __loc) throw ();
|
|
|
|
__extension__
|
|
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr,
|
|
int __base, __locale_t __loc)
|
|
throw ();
|
|
|
|
extern double wcstod_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, __locale_t __loc)
|
|
throw ();
|
|
|
|
extern float wcstof_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr, __locale_t __loc)
|
|
throw ();
|
|
|
|
extern long double wcstold_l (const wchar_t *__restrict __nptr,
|
|
wchar_t **__restrict __endptr,
|
|
__locale_t __loc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
|
|
const wchar_t *__restrict __src) throw ();
|
|
|
|
|
|
|
|
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
|
|
const wchar_t *__restrict __src, size_t __n)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fwide (__FILE *__fp, int __mode) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fwprintf (__FILE *__restrict __stream,
|
|
const wchar_t *__restrict __format, ...)
|
|
;
|
|
|
|
|
|
|
|
|
|
extern int wprintf (const wchar_t *__restrict __format, ...)
|
|
;
|
|
|
|
extern int swprintf (wchar_t *__restrict __s, size_t __n,
|
|
const wchar_t *__restrict __format, ...)
|
|
throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int vfwprintf (__FILE *__restrict __s,
|
|
const wchar_t *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
;
|
|
|
|
|
|
|
|
|
|
extern int vwprintf (const wchar_t *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
;
|
|
|
|
|
|
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
|
|
const wchar_t *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fwscanf (__FILE *__restrict __stream,
|
|
const wchar_t *__restrict __format, ...)
|
|
;
|
|
|
|
|
|
|
|
|
|
extern int wscanf (const wchar_t *__restrict __format, ...)
|
|
;
|
|
|
|
extern int swscanf (const wchar_t *__restrict __s,
|
|
const wchar_t *__restrict __format, ...)
|
|
throw () ;
|
|
# 680 "/usr/include/wchar.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int vfwscanf (__FILE *__restrict __s,
|
|
const wchar_t *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
;
|
|
|
|
|
|
|
|
|
|
extern int vwscanf (const wchar_t *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
;
|
|
|
|
extern int vswscanf (const wchar_t *__restrict __s,
|
|
const wchar_t *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
throw () ;
|
|
# 736 "/usr/include/wchar.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t fgetwc (__FILE *__stream);
|
|
extern wint_t getwc (__FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t getwchar (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
|
|
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t putwchar (wchar_t __wc);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
|
|
__FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int fputws (const wchar_t *__restrict __ws,
|
|
__FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
|
|
|
|
# 801 "/usr/include/wchar.h" 3 4
|
|
extern wint_t getwc_unlocked (__FILE *__stream);
|
|
extern wint_t getwchar_unlocked (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t fgetwc_unlocked (__FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
|
|
# 827 "/usr/include/wchar.h" 3 4
|
|
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
|
|
extern wint_t putwchar_unlocked (wchar_t __wc);
|
|
# 837 "/usr/include/wchar.h" 3 4
|
|
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
|
|
__FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fputws_unlocked (const wchar_t *__restrict __ws,
|
|
__FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
|
|
const wchar_t *__restrict __format,
|
|
const struct tm *__restrict __tp) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
|
|
const wchar_t *__restrict __format,
|
|
const struct tm *__restrict __tp,
|
|
__locale_t __loc) throw ();
|
|
# 891 "/usr/include/wchar.h" 3 4
|
|
}
|
|
# 45 "/usr/include/c++/4.8.2/cwchar" 2 3
|
|
# 62 "/usr/include/c++/4.8.2/cwchar" 3
|
|
namespace std
|
|
{
|
|
using ::mbstate_t;
|
|
}
|
|
# 135 "/usr/include/c++/4.8.2/cwchar" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
using ::wint_t;
|
|
|
|
using ::btowc;
|
|
using ::fgetwc;
|
|
using ::fgetws;
|
|
using ::fputwc;
|
|
using ::fputws;
|
|
using ::fwide;
|
|
using ::fwprintf;
|
|
using ::fwscanf;
|
|
using ::getwc;
|
|
using ::getwchar;
|
|
using ::mbrlen;
|
|
using ::mbrtowc;
|
|
using ::mbsinit;
|
|
using ::mbsrtowcs;
|
|
using ::putwc;
|
|
using ::putwchar;
|
|
|
|
using ::swprintf;
|
|
|
|
using ::swscanf;
|
|
using ::ungetwc;
|
|
using ::vfwprintf;
|
|
|
|
using ::vfwscanf;
|
|
|
|
|
|
using ::vswprintf;
|
|
|
|
|
|
using ::vswscanf;
|
|
|
|
using ::vwprintf;
|
|
|
|
using ::vwscanf;
|
|
|
|
using ::wcrtomb;
|
|
using ::wcscat;
|
|
using ::wcscmp;
|
|
using ::wcscoll;
|
|
using ::wcscpy;
|
|
using ::wcscspn;
|
|
using ::wcsftime;
|
|
using ::wcslen;
|
|
using ::wcsncat;
|
|
using ::wcsncmp;
|
|
using ::wcsncpy;
|
|
using ::wcsrtombs;
|
|
using ::wcsspn;
|
|
using ::wcstod;
|
|
|
|
using ::wcstof;
|
|
|
|
using ::wcstok;
|
|
using ::wcstol;
|
|
using ::wcstoul;
|
|
using ::wcsxfrm;
|
|
using ::wctob;
|
|
using ::wmemcmp;
|
|
using ::wmemcpy;
|
|
using ::wmemmove;
|
|
using ::wmemset;
|
|
using ::wprintf;
|
|
using ::wscanf;
|
|
using ::wcschr;
|
|
using ::wcspbrk;
|
|
using ::wcsrchr;
|
|
using ::wcsstr;
|
|
using ::wmemchr;
|
|
# 232 "/usr/include/c++/4.8.2/cwchar" 3
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace __gnu_cxx
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
using ::wcstold;
|
|
# 257 "/usr/include/c++/4.8.2/cwchar" 3
|
|
using ::wcstoll;
|
|
using ::wcstoull;
|
|
|
|
}
|
|
|
|
namespace std
|
|
{
|
|
using ::__gnu_cxx::wcstold;
|
|
using ::__gnu_cxx::wcstoll;
|
|
using ::__gnu_cxx::wcstoull;
|
|
}
|
|
# 41 "/usr/include/c++/4.8.2/bits/postypes.h" 2 3
|
|
# 68 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 88 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
typedef long streamoff;
|
|
# 98 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
typedef ptrdiff_t streamsize;
|
|
# 111 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
template<typename _StateT>
|
|
class fpos
|
|
{
|
|
private:
|
|
streamoff _M_off;
|
|
_StateT _M_state;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
fpos()
|
|
: _M_off(0), _M_state() { }
|
|
# 133 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
fpos(streamoff __off)
|
|
: _M_off(__off), _M_state() { }
|
|
|
|
|
|
operator streamoff() const { return _M_off; }
|
|
|
|
|
|
void
|
|
state(_StateT __st)
|
|
{ _M_state = __st; }
|
|
|
|
|
|
_StateT
|
|
state() const
|
|
{ return _M_state; }
|
|
|
|
|
|
|
|
|
|
|
|
fpos&
|
|
operator+=(streamoff __off)
|
|
{
|
|
_M_off += __off;
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fpos&
|
|
operator-=(streamoff __off)
|
|
{
|
|
_M_off -= __off;
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fpos
|
|
operator+(streamoff __off) const
|
|
{
|
|
fpos __pos(*this);
|
|
__pos += __off;
|
|
return __pos;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fpos
|
|
operator-(streamoff __off) const
|
|
{
|
|
fpos __pos(*this);
|
|
__pos -= __off;
|
|
return __pos;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
streamoff
|
|
operator-(const fpos& __other) const
|
|
{ return _M_off - __other._M_off; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _StateT>
|
|
inline bool
|
|
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
|
|
{ return streamoff(__lhs) == streamoff(__rhs); }
|
|
|
|
template<typename _StateT>
|
|
inline bool
|
|
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
|
|
{ return streamoff(__lhs) != streamoff(__rhs); }
|
|
|
|
|
|
|
|
|
|
|
|
typedef fpos<mbstate_t> streampos;
|
|
|
|
typedef fpos<mbstate_t> wstreampos;
|
|
# 239 "/usr/include/c++/4.8.2/bits/postypes.h" 3
|
|
|
|
}
|
|
# 41 "/usr/include/c++/4.8.2/iosfwd" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 74 "/usr/include/c++/4.8.2/iosfwd" 3
|
|
class ios_base;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_ios;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_streambuf;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_istream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_ostream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_iostream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT>,
|
|
typename _Alloc = allocator<_CharT> >
|
|
class basic_stringbuf;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT>,
|
|
typename _Alloc = allocator<_CharT> >
|
|
class basic_istringstream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT>,
|
|
typename _Alloc = allocator<_CharT> >
|
|
class basic_ostringstream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT>,
|
|
typename _Alloc = allocator<_CharT> >
|
|
class basic_stringstream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_filebuf;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_ifstream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_ofstream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class basic_fstream;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class istreambuf_iterator;
|
|
|
|
template<typename _CharT, typename _Traits = char_traits<_CharT> >
|
|
class ostreambuf_iterator;
|
|
|
|
|
|
|
|
typedef basic_ios<char> ios;
|
|
|
|
|
|
typedef basic_streambuf<char> streambuf;
|
|
|
|
|
|
typedef basic_istream<char> istream;
|
|
|
|
|
|
typedef basic_ostream<char> ostream;
|
|
|
|
|
|
typedef basic_iostream<char> iostream;
|
|
|
|
|
|
typedef basic_stringbuf<char> stringbuf;
|
|
|
|
|
|
typedef basic_istringstream<char> istringstream;
|
|
|
|
|
|
typedef basic_ostringstream<char> ostringstream;
|
|
|
|
|
|
typedef basic_stringstream<char> stringstream;
|
|
|
|
|
|
typedef basic_filebuf<char> filebuf;
|
|
|
|
|
|
typedef basic_ifstream<char> ifstream;
|
|
|
|
|
|
typedef basic_ofstream<char> ofstream;
|
|
|
|
|
|
typedef basic_fstream<char> fstream;
|
|
|
|
|
|
|
|
typedef basic_ios<wchar_t> wios;
|
|
|
|
|
|
typedef basic_streambuf<wchar_t> wstreambuf;
|
|
|
|
|
|
typedef basic_istream<wchar_t> wistream;
|
|
|
|
|
|
typedef basic_ostream<wchar_t> wostream;
|
|
|
|
|
|
typedef basic_iostream<wchar_t> wiostream;
|
|
|
|
|
|
typedef basic_stringbuf<wchar_t> wstringbuf;
|
|
|
|
|
|
typedef basic_istringstream<wchar_t> wistringstream;
|
|
|
|
|
|
typedef basic_ostringstream<wchar_t> wostringstream;
|
|
|
|
|
|
typedef basic_stringstream<wchar_t> wstringstream;
|
|
|
|
|
|
typedef basic_filebuf<wchar_t> wfilebuf;
|
|
|
|
|
|
typedef basic_ifstream<wchar_t> wifstream;
|
|
|
|
|
|
typedef basic_ofstream<wchar_t> wofstream;
|
|
|
|
|
|
typedef basic_fstream<wchar_t> wfstream;
|
|
|
|
|
|
|
|
|
|
}
|
|
# 39 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/exception" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/exception" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/exception" 3
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/atomic_lockfree_defines.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/atomic_lockfree_defines.h" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/atomic_lockfree_defines.h" 3
|
|
# 39 "/usr/include/c++/4.8.2/exception" 2 3
|
|
|
|
extern "C++" {
|
|
|
|
namespace std
|
|
{
|
|
# 60 "/usr/include/c++/4.8.2/exception" 3
|
|
class exception
|
|
{
|
|
public:
|
|
exception() throw() { }
|
|
virtual ~exception() throw();
|
|
|
|
|
|
|
|
virtual const char* what() const throw();
|
|
};
|
|
|
|
|
|
|
|
class bad_exception : public exception
|
|
{
|
|
public:
|
|
bad_exception() throw() { }
|
|
|
|
|
|
|
|
virtual ~bad_exception() throw();
|
|
|
|
|
|
virtual const char* what() const throw();
|
|
};
|
|
|
|
|
|
typedef void (*terminate_handler) ();
|
|
|
|
|
|
typedef void (*unexpected_handler) ();
|
|
|
|
|
|
terminate_handler set_terminate(terminate_handler) throw();
|
|
|
|
|
|
|
|
void terminate() throw() __attribute__ ((__noreturn__));
|
|
|
|
|
|
unexpected_handler set_unexpected(unexpected_handler) throw();
|
|
|
|
|
|
|
|
void unexpected() __attribute__ ((__noreturn__));
|
|
# 117 "/usr/include/c++/4.8.2/exception" 3
|
|
bool uncaught_exception() throw() __attribute__ ((__pure__));
|
|
|
|
|
|
}
|
|
|
|
namespace __gnu_cxx
|
|
{
|
|
|
|
# 142 "/usr/include/c++/4.8.2/exception" 3
|
|
void __verbose_terminate_handler();
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#pragma GCC visibility pop
|
|
# 40 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/char_traits.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 1 3
|
|
# 60 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/functexcept.h" 1 3
|
|
# 40 "/usr/include/c++/4.8.2/bits/functexcept.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/exception_defines.h" 1 3
|
|
# 41 "/usr/include/c++/4.8.2/bits/functexcept.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
void
|
|
__throw_bad_exception(void) __attribute__((__noreturn__));
|
|
|
|
|
|
void
|
|
__throw_bad_alloc(void) __attribute__((__noreturn__));
|
|
|
|
|
|
void
|
|
__throw_bad_cast(void) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_bad_typeid(void) __attribute__((__noreturn__));
|
|
|
|
|
|
void
|
|
__throw_logic_error(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_domain_error(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_invalid_argument(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_length_error(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_out_of_range(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_runtime_error(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_range_error(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_overflow_error(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_underflow_error(const char*) __attribute__((__noreturn__));
|
|
|
|
|
|
void
|
|
__throw_ios_failure(const char*) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_system_error(int) __attribute__((__noreturn__));
|
|
|
|
void
|
|
__throw_future_error(int) __attribute__((__noreturn__));
|
|
|
|
|
|
void
|
|
__throw_bad_function_call() __attribute__((__noreturn__));
|
|
|
|
|
|
}
|
|
# 61 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 1 3
|
|
# 35 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
|
|
|
|
# 36 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
|
|
# 68 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
class __normal_iterator;
|
|
|
|
|
|
}
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
struct __true_type { };
|
|
struct __false_type { };
|
|
|
|
template<bool>
|
|
struct __truth_type
|
|
{ typedef __false_type __type; };
|
|
|
|
template<>
|
|
struct __truth_type<true>
|
|
{ typedef __true_type __type; };
|
|
|
|
|
|
|
|
template<class _Sp, class _Tp>
|
|
struct __traitor
|
|
{
|
|
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
|
|
typedef typename __truth_type<__value>::__type __type;
|
|
};
|
|
|
|
|
|
template<typename, typename>
|
|
struct __are_same
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
template<typename _Tp>
|
|
struct __are_same<_Tp, _Tp>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_void
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_void<void>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_integer
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<>
|
|
struct __is_integer<bool>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<signed char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<unsigned char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
template<>
|
|
struct __is_integer<wchar_t>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
# 198 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
|
|
template<>
|
|
struct __is_integer<short>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<unsigned short>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<int>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<unsigned int>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<long>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<unsigned long>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<long long>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_integer<unsigned long long>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_floating
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
|
|
template<>
|
|
struct __is_floating<float>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_floating<double>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_floating<long double>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_pointer
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
template<typename _Tp>
|
|
struct __is_pointer<_Tp*>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_normal_iterator
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
|
|
_Container> >
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_arithmetic
|
|
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
|
|
{ };
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_fundamental
|
|
: public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
|
|
{ };
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_scalar
|
|
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
|
|
{ };
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_char
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_char<char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
template<>
|
|
struct __is_char<wchar_t>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_byte
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_byte<char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_byte<signed char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __is_byte<unsigned char>
|
|
{
|
|
enum { __value = 1 };
|
|
typedef __true_type __type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __is_move_iterator
|
|
{
|
|
enum { __value = 0 };
|
|
typedef __false_type __type;
|
|
};
|
|
# 421 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
|
|
|
|
}
|
|
# 62 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/ext/type_traits.h" 1 3
|
|
# 32 "/usr/include/c++/4.8.2/ext/type_traits.h" 3
|
|
|
|
# 33 "/usr/include/c++/4.8.2/ext/type_traits.h" 3
|
|
|
|
|
|
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
template<bool, typename>
|
|
struct __enable_if
|
|
{ };
|
|
|
|
template<typename _Tp>
|
|
struct __enable_if<true, _Tp>
|
|
{ typedef _Tp __type; };
|
|
|
|
|
|
|
|
template<bool _Cond, typename _Iftrue, typename _Iffalse>
|
|
struct __conditional_type
|
|
{ typedef _Iftrue __type; };
|
|
|
|
template<typename _Iftrue, typename _Iffalse>
|
|
struct __conditional_type<false, _Iftrue, _Iffalse>
|
|
{ typedef _Iffalse __type; };
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __add_unsigned
|
|
{
|
|
private:
|
|
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
|
|
|
|
public:
|
|
typedef typename __if_type::__type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __add_unsigned<char>
|
|
{ typedef unsigned char __type; };
|
|
|
|
template<>
|
|
struct __add_unsigned<signed char>
|
|
{ typedef unsigned char __type; };
|
|
|
|
template<>
|
|
struct __add_unsigned<short>
|
|
{ typedef unsigned short __type; };
|
|
|
|
template<>
|
|
struct __add_unsigned<int>
|
|
{ typedef unsigned int __type; };
|
|
|
|
template<>
|
|
struct __add_unsigned<long>
|
|
{ typedef unsigned long __type; };
|
|
|
|
template<>
|
|
struct __add_unsigned<long long>
|
|
{ typedef unsigned long long __type; };
|
|
|
|
|
|
template<>
|
|
struct __add_unsigned<bool>;
|
|
|
|
template<>
|
|
struct __add_unsigned<wchar_t>;
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __remove_unsigned
|
|
{
|
|
private:
|
|
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
|
|
|
|
public:
|
|
typedef typename __if_type::__type __type;
|
|
};
|
|
|
|
template<>
|
|
struct __remove_unsigned<char>
|
|
{ typedef signed char __type; };
|
|
|
|
template<>
|
|
struct __remove_unsigned<unsigned char>
|
|
{ typedef signed char __type; };
|
|
|
|
template<>
|
|
struct __remove_unsigned<unsigned short>
|
|
{ typedef short __type; };
|
|
|
|
template<>
|
|
struct __remove_unsigned<unsigned int>
|
|
{ typedef int __type; };
|
|
|
|
template<>
|
|
struct __remove_unsigned<unsigned long>
|
|
{ typedef long __type; };
|
|
|
|
template<>
|
|
struct __remove_unsigned<unsigned long long>
|
|
{ typedef long long __type; };
|
|
|
|
|
|
template<>
|
|
struct __remove_unsigned<bool>;
|
|
|
|
template<>
|
|
struct __remove_unsigned<wchar_t>;
|
|
|
|
|
|
|
|
template<typename _Type>
|
|
inline bool
|
|
__is_null_pointer(_Type* __ptr)
|
|
{ return __ptr == 0; }
|
|
|
|
template<typename _Type>
|
|
inline bool
|
|
__is_null_pointer(_Type)
|
|
{ return false; }
|
|
|
|
|
|
|
|
template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
|
|
struct __promote
|
|
{ typedef double __type; };
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct __promote<_Tp, false>
|
|
{ };
|
|
|
|
template<>
|
|
struct __promote<long double>
|
|
{ typedef long double __type; };
|
|
|
|
template<>
|
|
struct __promote<double>
|
|
{ typedef double __type; };
|
|
|
|
template<>
|
|
struct __promote<float>
|
|
{ typedef float __type; };
|
|
|
|
template<typename _Tp, typename _Up,
|
|
typename _Tp2 = typename __promote<_Tp>::__type,
|
|
typename _Up2 = typename __promote<_Up>::__type>
|
|
struct __promote_2
|
|
{
|
|
typedef __typeof__(_Tp2() + _Up2()) __type;
|
|
};
|
|
|
|
template<typename _Tp, typename _Up, typename _Vp,
|
|
typename _Tp2 = typename __promote<_Tp>::__type,
|
|
typename _Up2 = typename __promote<_Up>::__type,
|
|
typename _Vp2 = typename __promote<_Vp>::__type>
|
|
struct __promote_3
|
|
{
|
|
typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
|
|
};
|
|
|
|
template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
|
|
typename _Tp2 = typename __promote<_Tp>::__type,
|
|
typename _Up2 = typename __promote<_Up>::__type,
|
|
typename _Vp2 = typename __promote<_Vp>::__type,
|
|
typename _Wp2 = typename __promote<_Wp>::__type>
|
|
struct __promote_4
|
|
{
|
|
typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
|
|
};
|
|
|
|
|
|
}
|
|
# 63 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 1 3
|
|
# 32 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
|
|
|
|
# 33 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
|
|
|
|
|
|
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 54 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
|
|
template<typename _Value>
|
|
struct __numeric_traits_integer
|
|
{
|
|
|
|
static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
|
|
static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
|
|
|
|
|
|
|
|
static const bool __is_signed = ((_Value)(-1) < 0);
|
|
static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
|
|
};
|
|
|
|
template<typename _Value>
|
|
const _Value __numeric_traits_integer<_Value>::__min;
|
|
|
|
template<typename _Value>
|
|
const _Value __numeric_traits_integer<_Value>::__max;
|
|
|
|
template<typename _Value>
|
|
const bool __numeric_traits_integer<_Value>::__is_signed;
|
|
|
|
template<typename _Value>
|
|
const int __numeric_traits_integer<_Value>::__digits;
|
|
# 99 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
|
|
template<typename _Value>
|
|
struct __numeric_traits_floating
|
|
{
|
|
|
|
static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
|
|
|
|
|
|
static const bool __is_signed = true;
|
|
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
|
|
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
|
|
};
|
|
|
|
template<typename _Value>
|
|
const int __numeric_traits_floating<_Value>::__max_digits10;
|
|
|
|
template<typename _Value>
|
|
const bool __numeric_traits_floating<_Value>::__is_signed;
|
|
|
|
template<typename _Value>
|
|
const int __numeric_traits_floating<_Value>::__digits10;
|
|
|
|
template<typename _Value>
|
|
const int __numeric_traits_floating<_Value>::__max_exponent10;
|
|
|
|
template<typename _Value>
|
|
struct __numeric_traits
|
|
: public __conditional_type<std::__is_integer<_Value>::__value,
|
|
__numeric_traits_integer<_Value>,
|
|
__numeric_traits_floating<_Value> >::__type
|
|
{ };
|
|
|
|
|
|
}
|
|
# 64 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_pair.h" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/move.h" 1 3
|
|
# 34 "/usr/include/c++/4.8.2/bits/move.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/concept_check.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/concept_check.h" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/concept_check.h" 3
|
|
# 35 "/usr/include/c++/4.8.2/bits/move.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
inline _Tp*
|
|
__addressof(_Tp& __r)
|
|
{
|
|
return reinterpret_cast<_Tp*>
|
|
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
|
|
}
|
|
|
|
|
|
}
|
|
# 149 "/usr/include/c++/4.8.2/bits/move.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 164 "/usr/include/c++/4.8.2/bits/move.h" 3
|
|
template<typename _Tp>
|
|
inline void
|
|
swap(_Tp& __a, _Tp& __b)
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
|
|
|
_Tp __tmp = (__a);
|
|
__a = (__b);
|
|
__b = (__tmp);
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t _Nm>
|
|
inline void
|
|
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
|
|
|
|
|
|
|
|
{
|
|
for (size_t __n = 0; __n < _Nm; ++__n)
|
|
swap(__a[__n], __b[__n]);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
# 60 "/usr/include/c++/4.8.2/bits/stl_pair.h" 2 3
|
|
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 95 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
|
|
template<class _T1, class _T2>
|
|
struct pair
|
|
{
|
|
typedef _T1 first_type;
|
|
typedef _T2 second_type;
|
|
|
|
_T1 first;
|
|
_T2 second;
|
|
|
|
|
|
|
|
|
|
|
|
pair()
|
|
: first(), second() { }
|
|
|
|
|
|
pair(const _T1& __a, const _T2& __b)
|
|
: first(__a), second(__b) { }
|
|
|
|
|
|
|
|
template<class _U1, class _U2>
|
|
pair(const pair<_U1, _U2>& __p)
|
|
: first(__p.first), second(__p.second) { }
|
|
# 209 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
|
|
};
|
|
|
|
|
|
template<class _T1, class _T2>
|
|
inline bool
|
|
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
|
{ return __x.first == __y.first && __x.second == __y.second; }
|
|
|
|
|
|
template<class _T1, class _T2>
|
|
inline bool
|
|
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
|
{ return __x.first < __y.first
|
|
|| (!(__y.first < __x.first) && __x.second < __y.second); }
|
|
|
|
|
|
template<class _T1, class _T2>
|
|
inline bool
|
|
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<class _T1, class _T2>
|
|
inline bool
|
|
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<class _T1, class _T2>
|
|
inline bool
|
|
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<class _T1, class _T2>
|
|
inline bool
|
|
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
|
{ return !(__x < __y); }
|
|
# 284 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
|
|
template<class _T1, class _T2>
|
|
inline pair<_T1, _T2>
|
|
make_pair(_T1 __x, _T2 __y)
|
|
{ return pair<_T1, _T2>(__x, __y); }
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
# 65 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 1 3
|
|
# 62 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
|
|
|
|
# 63 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 89 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
|
|
struct input_iterator_tag { };
|
|
|
|
|
|
struct output_iterator_tag { };
|
|
|
|
|
|
struct forward_iterator_tag : public input_iterator_tag { };
|
|
|
|
|
|
|
|
struct bidirectional_iterator_tag : public forward_iterator_tag { };
|
|
|
|
|
|
|
|
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
|
|
# 116 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
|
|
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
|
|
typename _Pointer = _Tp*, typename _Reference = _Tp&>
|
|
struct iterator
|
|
{
|
|
|
|
typedef _Category iterator_category;
|
|
|
|
typedef _Tp value_type;
|
|
|
|
typedef _Distance difference_type;
|
|
|
|
typedef _Pointer pointer;
|
|
|
|
typedef _Reference reference;
|
|
};
|
|
# 162 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
|
|
template<typename _Iterator>
|
|
struct iterator_traits
|
|
{
|
|
typedef typename _Iterator::iterator_category iterator_category;
|
|
typedef typename _Iterator::value_type value_type;
|
|
typedef typename _Iterator::difference_type difference_type;
|
|
typedef typename _Iterator::pointer pointer;
|
|
typedef typename _Iterator::reference reference;
|
|
};
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct iterator_traits<_Tp*>
|
|
{
|
|
typedef random_access_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Tp* pointer;
|
|
typedef _Tp& reference;
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct iterator_traits<const _Tp*>
|
|
{
|
|
typedef random_access_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef const _Tp* pointer;
|
|
typedef const _Tp& reference;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Iter>
|
|
inline typename iterator_traits<_Iter>::iterator_category
|
|
__iterator_category(const _Iter&)
|
|
{ return typename iterator_traits<_Iter>::iterator_category(); }
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Iterator, bool _HasBase>
|
|
struct _Iter_base
|
|
{
|
|
typedef _Iterator iterator_type;
|
|
static iterator_type _S_base(_Iterator __it)
|
|
{ return __it; }
|
|
};
|
|
|
|
template<typename _Iterator>
|
|
struct _Iter_base<_Iterator, true>
|
|
{
|
|
typedef typename _Iterator::iterator_type iterator_type;
|
|
static iterator_type _S_base(_Iterator __it)
|
|
{ return __it.base(); }
|
|
};
|
|
# 232 "/usr/include/c++/4.8.2/bits/stl_iterator_base_types.h" 3
|
|
|
|
}
|
|
# 66 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 1 3
|
|
# 62 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
|
|
|
|
# 63 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/debug/debug.h" 1 3
|
|
# 46 "/usr/include/c++/4.8.2/debug/debug.h" 3
|
|
namespace std
|
|
{
|
|
namespace __debug { }
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace __gnu_debug
|
|
{
|
|
using namespace std::__debug;
|
|
}
|
|
# 66 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _InputIterator>
|
|
inline typename iterator_traits<_InputIterator>::difference_type
|
|
__distance(_InputIterator __first, _InputIterator __last,
|
|
input_iterator_tag)
|
|
{
|
|
|
|
|
|
|
|
typename iterator_traits<_InputIterator>::difference_type __n = 0;
|
|
while (__first != __last)
|
|
{
|
|
++__first;
|
|
++__n;
|
|
}
|
|
return __n;
|
|
}
|
|
|
|
template<typename _RandomAccessIterator>
|
|
inline typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
random_access_iterator_tag)
|
|
{
|
|
|
|
|
|
|
|
return __last - __first;
|
|
}
|
|
# 112 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
|
|
template<typename _InputIterator>
|
|
inline typename iterator_traits<_InputIterator>::difference_type
|
|
distance(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
|
|
return std::__distance(__first, __last,
|
|
std::__iterator_category(__first));
|
|
}
|
|
|
|
template<typename _InputIterator, typename _Distance>
|
|
inline void
|
|
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
|
|
{
|
|
|
|
|
|
;
|
|
while (__n--)
|
|
++__i;
|
|
}
|
|
|
|
template<typename _BidirectionalIterator, typename _Distance>
|
|
inline void
|
|
__advance(_BidirectionalIterator& __i, _Distance __n,
|
|
bidirectional_iterator_tag)
|
|
{
|
|
|
|
|
|
|
|
if (__n > 0)
|
|
while (__n--)
|
|
++__i;
|
|
else
|
|
while (__n++)
|
|
--__i;
|
|
}
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance>
|
|
inline void
|
|
__advance(_RandomAccessIterator& __i, _Distance __n,
|
|
random_access_iterator_tag)
|
|
{
|
|
|
|
|
|
|
|
__i += __n;
|
|
}
|
|
# 171 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
|
|
template<typename _InputIterator, typename _Distance>
|
|
inline void
|
|
advance(_InputIterator& __i, _Distance __n)
|
|
{
|
|
|
|
typename iterator_traits<_InputIterator>::difference_type __d = __n;
|
|
std::__advance(__i, __d, std::__iterator_category(__i));
|
|
}
|
|
# 202 "/usr/include/c++/4.8.2/bits/stl_iterator_base_funcs.h" 3
|
|
|
|
}
|
|
# 67 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 1 3
|
|
# 67 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 95 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Iterator>
|
|
class reverse_iterator
|
|
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
|
|
typename iterator_traits<_Iterator>::value_type,
|
|
typename iterator_traits<_Iterator>::difference_type,
|
|
typename iterator_traits<_Iterator>::pointer,
|
|
typename iterator_traits<_Iterator>::reference>
|
|
{
|
|
protected:
|
|
_Iterator current;
|
|
|
|
typedef iterator_traits<_Iterator> __traits_type;
|
|
|
|
public:
|
|
typedef _Iterator iterator_type;
|
|
typedef typename __traits_type::difference_type difference_type;
|
|
typedef typename __traits_type::pointer pointer;
|
|
typedef typename __traits_type::reference reference;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator() : current() { }
|
|
|
|
|
|
|
|
|
|
explicit
|
|
reverse_iterator(iterator_type __x) : current(__x) { }
|
|
|
|
|
|
|
|
|
|
reverse_iterator(const reverse_iterator& __x)
|
|
: current(__x.current) { }
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Iter>
|
|
reverse_iterator(const reverse_iterator<_Iter>& __x)
|
|
: current(__x.base()) { }
|
|
|
|
|
|
|
|
|
|
iterator_type
|
|
base() const
|
|
{ return current; }
|
|
# 159 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
reference
|
|
operator*() const
|
|
{
|
|
_Iterator __tmp = current;
|
|
return *--__tmp;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return &(operator*()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator&
|
|
operator++()
|
|
{
|
|
--current;
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
operator++(int)
|
|
{
|
|
reverse_iterator __tmp = *this;
|
|
--current;
|
|
return __tmp;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator&
|
|
operator--()
|
|
{
|
|
++current;
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
operator--(int)
|
|
{
|
|
reverse_iterator __tmp = *this;
|
|
++current;
|
|
return __tmp;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
operator+(difference_type __n) const
|
|
{ return reverse_iterator(current - __n); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator&
|
|
operator+=(difference_type __n)
|
|
{
|
|
current -= __n;
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
operator-(difference_type __n) const
|
|
{ return reverse_iterator(current + __n); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator&
|
|
operator-=(difference_type __n)
|
|
{
|
|
current += __n;
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
operator[](difference_type __n) const
|
|
{ return *(*this + __n); }
|
|
};
|
|
# 289 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Iterator>
|
|
inline bool
|
|
operator==(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return __x.base() == __y.base(); }
|
|
|
|
template<typename _Iterator>
|
|
inline bool
|
|
operator<(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return __y.base() < __x.base(); }
|
|
|
|
template<typename _Iterator>
|
|
inline bool
|
|
operator!=(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
template<typename _Iterator>
|
|
inline bool
|
|
operator>(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return __y < __x; }
|
|
|
|
template<typename _Iterator>
|
|
inline bool
|
|
operator<=(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
template<typename _Iterator>
|
|
inline bool
|
|
operator>=(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
template<typename _Iterator>
|
|
inline typename reverse_iterator<_Iterator>::difference_type
|
|
operator-(const reverse_iterator<_Iterator>& __x,
|
|
const reverse_iterator<_Iterator>& __y)
|
|
{ return __y.base() - __x.base(); }
|
|
|
|
template<typename _Iterator>
|
|
inline reverse_iterator<_Iterator>
|
|
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
|
|
const reverse_iterator<_Iterator>& __x)
|
|
{ return reverse_iterator<_Iterator>(__x.base() - __n); }
|
|
|
|
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
inline bool
|
|
operator==(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
{ return __x.base() == __y.base(); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
inline bool
|
|
operator<(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
{ return __y.base() < __x.base(); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
inline bool
|
|
operator!=(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
inline bool
|
|
operator>(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
{ return __y < __x; }
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
inline bool
|
|
operator<=(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
inline bool
|
|
operator>=(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
inline typename reverse_iterator<_IteratorL>::difference_type
|
|
operator-(const reverse_iterator<_IteratorL>& __x,
|
|
const reverse_iterator<_IteratorR>& __y)
|
|
|
|
{ return __y.base() - __x.base(); }
|
|
# 401 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Container>
|
|
class back_insert_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void>
|
|
{
|
|
protected:
|
|
_Container* container;
|
|
|
|
public:
|
|
|
|
typedef _Container container_type;
|
|
|
|
|
|
explicit
|
|
back_insert_iterator(_Container& __x) : container(&__x) { }
|
|
# 428 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
back_insert_iterator&
|
|
operator=(typename _Container::const_reference __value)
|
|
{
|
|
container->push_back(__value);
|
|
return *this;
|
|
}
|
|
# 451 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
back_insert_iterator&
|
|
operator*()
|
|
{ return *this; }
|
|
|
|
|
|
back_insert_iterator&
|
|
operator++()
|
|
{ return *this; }
|
|
|
|
|
|
back_insert_iterator
|
|
operator++(int)
|
|
{ return *this; }
|
|
};
|
|
# 477 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Container>
|
|
inline back_insert_iterator<_Container>
|
|
back_inserter(_Container& __x)
|
|
{ return back_insert_iterator<_Container>(__x); }
|
|
# 492 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Container>
|
|
class front_insert_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void>
|
|
{
|
|
protected:
|
|
_Container* container;
|
|
|
|
public:
|
|
|
|
typedef _Container container_type;
|
|
|
|
|
|
explicit front_insert_iterator(_Container& __x) : container(&__x) { }
|
|
# 518 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
front_insert_iterator&
|
|
operator=(typename _Container::const_reference __value)
|
|
{
|
|
container->push_front(__value);
|
|
return *this;
|
|
}
|
|
# 541 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
front_insert_iterator&
|
|
operator*()
|
|
{ return *this; }
|
|
|
|
|
|
front_insert_iterator&
|
|
operator++()
|
|
{ return *this; }
|
|
|
|
|
|
front_insert_iterator
|
|
operator++(int)
|
|
{ return *this; }
|
|
};
|
|
# 567 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Container>
|
|
inline front_insert_iterator<_Container>
|
|
front_inserter(_Container& __x)
|
|
{ return front_insert_iterator<_Container>(__x); }
|
|
# 586 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Container>
|
|
class insert_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void>
|
|
{
|
|
protected:
|
|
_Container* container;
|
|
typename _Container::iterator iter;
|
|
|
|
public:
|
|
|
|
typedef _Container container_type;
|
|
|
|
|
|
|
|
|
|
|
|
insert_iterator(_Container& __x, typename _Container::iterator __i)
|
|
: container(&__x), iter(__i) {}
|
|
# 629 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
insert_iterator&
|
|
operator=(typename _Container::const_reference __value)
|
|
{
|
|
iter = container->insert(iter, __value);
|
|
++iter;
|
|
return *this;
|
|
}
|
|
# 655 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
insert_iterator&
|
|
operator*()
|
|
{ return *this; }
|
|
|
|
|
|
insert_iterator&
|
|
operator++()
|
|
{ return *this; }
|
|
|
|
|
|
insert_iterator&
|
|
operator++(int)
|
|
{ return *this; }
|
|
};
|
|
# 681 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _Container, typename _Iterator>
|
|
inline insert_iterator<_Container>
|
|
inserter(_Container& __x, _Iterator __i)
|
|
{
|
|
return insert_iterator<_Container>(__x,
|
|
typename _Container::iterator(__i));
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 705 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
using std::iterator_traits;
|
|
using std::iterator;
|
|
template<typename _Iterator, typename _Container>
|
|
class __normal_iterator
|
|
{
|
|
protected:
|
|
_Iterator _M_current;
|
|
|
|
typedef iterator_traits<_Iterator> __traits_type;
|
|
|
|
public:
|
|
typedef _Iterator iterator_type;
|
|
typedef typename __traits_type::iterator_category iterator_category;
|
|
typedef typename __traits_type::value_type value_type;
|
|
typedef typename __traits_type::difference_type difference_type;
|
|
typedef typename __traits_type::reference reference;
|
|
typedef typename __traits_type::pointer pointer;
|
|
|
|
__normal_iterator() : _M_current(_Iterator()) { }
|
|
|
|
explicit
|
|
__normal_iterator(const _Iterator& __i) : _M_current(__i) { }
|
|
|
|
|
|
template<typename _Iter>
|
|
__normal_iterator(const __normal_iterator<_Iter,
|
|
typename __enable_if<
|
|
(std::__are_same<_Iter, typename _Container::pointer>::__value),
|
|
_Container>::__type>& __i)
|
|
: _M_current(__i.base()) { }
|
|
|
|
|
|
reference
|
|
operator*() const
|
|
{ return *_M_current; }
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return _M_current; }
|
|
|
|
__normal_iterator&
|
|
operator++()
|
|
{
|
|
++_M_current;
|
|
return *this;
|
|
}
|
|
|
|
__normal_iterator
|
|
operator++(int)
|
|
{ return __normal_iterator(_M_current++); }
|
|
|
|
|
|
__normal_iterator&
|
|
operator--()
|
|
{
|
|
--_M_current;
|
|
return *this;
|
|
}
|
|
|
|
__normal_iterator
|
|
operator--(int)
|
|
{ return __normal_iterator(_M_current--); }
|
|
|
|
|
|
reference
|
|
operator[](const difference_type& __n) const
|
|
{ return _M_current[__n]; }
|
|
|
|
__normal_iterator&
|
|
operator+=(const difference_type& __n)
|
|
{ _M_current += __n; return *this; }
|
|
|
|
__normal_iterator
|
|
operator+(const difference_type& __n) const
|
|
{ return __normal_iterator(_M_current + __n); }
|
|
|
|
__normal_iterator&
|
|
operator-=(const difference_type& __n)
|
|
{ _M_current -= __n; return *this; }
|
|
|
|
__normal_iterator
|
|
operator-(const difference_type& __n) const
|
|
{ return __normal_iterator(_M_current - __n); }
|
|
|
|
const _Iterator&
|
|
base() const
|
|
{ return _M_current; }
|
|
};
|
|
# 803 "/usr/include/c++/4.8.2/bits/stl_iterator.h" 3
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
inline bool
|
|
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
{ return __lhs.base() == __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline bool
|
|
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() == __rhs.base(); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
inline bool
|
|
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
{ return __lhs.base() != __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline bool
|
|
operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() != __rhs.base(); }
|
|
|
|
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
inline bool
|
|
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
{ return __lhs.base() < __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline bool
|
|
operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() < __rhs.base(); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
inline bool
|
|
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
{ return __lhs.base() > __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline bool
|
|
operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() > __rhs.base(); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
inline bool
|
|
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
{ return __lhs.base() <= __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline bool
|
|
operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() <= __rhs.base(); }
|
|
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
inline bool
|
|
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
{ return __lhs.base() >= __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline bool
|
|
operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() >= __rhs.base(); }
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _IteratorL, typename _IteratorR, typename _Container>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
inline typename __normal_iterator<_IteratorL, _Container>::difference_type
|
|
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
|
|
const __normal_iterator<_IteratorR, _Container>& __rhs)
|
|
|
|
{ return __lhs.base() - __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline typename __normal_iterator<_Iterator, _Container>::difference_type
|
|
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
|
|
const __normal_iterator<_Iterator, _Container>& __rhs)
|
|
{ return __lhs.base() - __rhs.base(); }
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
inline __normal_iterator<_Iterator, _Container>
|
|
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
|
|
__n, const __normal_iterator<_Iterator, _Container>& __i)
|
|
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
|
|
|
|
|
|
}
|
|
# 68 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<bool _BoolType>
|
|
struct __iter_swap
|
|
{
|
|
template<typename _ForwardIterator1, typename _ForwardIterator2>
|
|
static void
|
|
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
|
|
{
|
|
typedef typename iterator_traits<_ForwardIterator1>::value_type
|
|
_ValueType1;
|
|
_ValueType1 __tmp = (*__a);
|
|
*__a = (*__b);
|
|
*__b = (__tmp);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct __iter_swap<true>
|
|
{
|
|
template<typename _ForwardIterator1, typename _ForwardIterator2>
|
|
static void
|
|
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
|
|
{
|
|
swap(*__a, *__b);
|
|
}
|
|
};
|
|
# 117 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _ForwardIterator1, typename _ForwardIterator2>
|
|
inline void
|
|
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef typename iterator_traits<_ForwardIterator1>::value_type
|
|
_ValueType1;
|
|
typedef typename iterator_traits<_ForwardIterator2>::value_type
|
|
_ValueType2;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef typename iterator_traits<_ForwardIterator1>::reference
|
|
_ReferenceType1;
|
|
typedef typename iterator_traits<_ForwardIterator2>::reference
|
|
_ReferenceType2;
|
|
std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
|
|
&& __are_same<_ValueType1&, _ReferenceType1>::__value
|
|
&& __are_same<_ValueType2&, _ReferenceType2>::__value>::
|
|
iter_swap(__a, __b);
|
|
|
|
|
|
|
|
}
|
|
# 163 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _ForwardIterator1, typename _ForwardIterator2>
|
|
_ForwardIterator2
|
|
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
for (; __first1 != __last1; ++__first1, ++__first2)
|
|
std::iter_swap(__first1, __first2);
|
|
return __first2;
|
|
}
|
|
# 191 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _Tp>
|
|
inline const _Tp&
|
|
min(const _Tp& __a, const _Tp& __b)
|
|
{
|
|
|
|
|
|
|
|
if (__b < __a)
|
|
return __b;
|
|
return __a;
|
|
}
|
|
# 214 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _Tp>
|
|
inline const _Tp&
|
|
max(const _Tp& __a, const _Tp& __b)
|
|
{
|
|
|
|
|
|
|
|
if (__a < __b)
|
|
return __b;
|
|
return __a;
|
|
}
|
|
# 237 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _Tp, typename _Compare>
|
|
inline const _Tp&
|
|
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
|
|
{
|
|
|
|
if (__comp(__b, __a))
|
|
return __b;
|
|
return __a;
|
|
}
|
|
# 258 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _Tp, typename _Compare>
|
|
inline const _Tp&
|
|
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
|
|
{
|
|
|
|
if (__comp(__a, __b))
|
|
return __b;
|
|
return __a;
|
|
}
|
|
|
|
|
|
|
|
template<typename _Iterator>
|
|
struct _Niter_base
|
|
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
|
|
{ };
|
|
|
|
template<typename _Iterator>
|
|
inline typename _Niter_base<_Iterator>::iterator_type
|
|
__niter_base(_Iterator __it)
|
|
{ return std::_Niter_base<_Iterator>::_S_base(__it); }
|
|
|
|
|
|
template<typename _Iterator>
|
|
struct _Miter_base
|
|
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
|
|
{ };
|
|
|
|
template<typename _Iterator>
|
|
inline typename _Miter_base<_Iterator>::iterator_type
|
|
__miter_base(_Iterator __it)
|
|
{ return std::_Miter_base<_Iterator>::_S_base(__it); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<bool, bool, typename>
|
|
struct __copy_move
|
|
{
|
|
template<typename _II, typename _OI>
|
|
static _OI
|
|
__copy_m(_II __first, _II __last, _OI __result)
|
|
{
|
|
for (; __first != __last; ++__result, ++__first)
|
|
*__result = *__first;
|
|
return __result;
|
|
}
|
|
};
|
|
# 325 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<>
|
|
struct __copy_move<false, false, random_access_iterator_tag>
|
|
{
|
|
template<typename _II, typename _OI>
|
|
static _OI
|
|
__copy_m(_II __first, _II __last, _OI __result)
|
|
{
|
|
typedef typename iterator_traits<_II>::difference_type _Distance;
|
|
for(_Distance __n = __last - __first; __n > 0; --__n)
|
|
{
|
|
*__result = *__first;
|
|
++__first;
|
|
++__result;
|
|
}
|
|
return __result;
|
|
}
|
|
};
|
|
# 363 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<bool _IsMove>
|
|
struct __copy_move<_IsMove, true, random_access_iterator_tag>
|
|
{
|
|
template<typename _Tp>
|
|
static _Tp*
|
|
__copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
|
|
{
|
|
const ptrdiff_t _Num = __last - __first;
|
|
if (_Num)
|
|
__builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
|
|
return __result + _Num;
|
|
}
|
|
};
|
|
|
|
template<bool _IsMove, typename _II, typename _OI>
|
|
inline _OI
|
|
__copy_move_a(_II __first, _II __last, _OI __result)
|
|
{
|
|
typedef typename iterator_traits<_II>::value_type _ValueTypeI;
|
|
typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
|
|
typedef typename iterator_traits<_II>::iterator_category _Category;
|
|
const bool __simple = (__is_trivial(_ValueTypeI)
|
|
&& __is_pointer<_II>::__value
|
|
&& __is_pointer<_OI>::__value
|
|
&& __are_same<_ValueTypeI, _ValueTypeO>::__value);
|
|
|
|
return std::__copy_move<_IsMove, __simple,
|
|
_Category>::__copy_m(__first, __last, __result);
|
|
}
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
struct char_traits;
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
class istreambuf_iterator;
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
class ostreambuf_iterator;
|
|
|
|
template<bool _IsMove, typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
|
|
__copy_move_a2(_CharT*, _CharT*,
|
|
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
|
|
|
|
template<bool _IsMove, typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
|
|
__copy_move_a2(const _CharT*, const _CharT*,
|
|
ostreambuf_iterator<_CharT, char_traits<_CharT> >);
|
|
|
|
template<bool _IsMove, typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
_CharT*>::__type
|
|
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
|
|
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
|
|
|
|
template<bool _IsMove, typename _II, typename _OI>
|
|
inline _OI
|
|
__copy_move_a2(_II __first, _II __last, _OI __result)
|
|
{
|
|
return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
|
|
std::__niter_base(__last),
|
|
std::__niter_base(__result)));
|
|
}
|
|
# 448 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _II, typename _OI>
|
|
inline _OI
|
|
copy(_II __first, _II __last, _OI __result)
|
|
{
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
|
|
(std::__miter_base(__first), std::__miter_base(__last),
|
|
__result));
|
|
}
|
|
# 500 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<bool, bool, typename>
|
|
struct __copy_move_backward
|
|
{
|
|
template<typename _BI1, typename _BI2>
|
|
static _BI2
|
|
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
|
|
{
|
|
while (__first != __last)
|
|
*--__result = *--__last;
|
|
return __result;
|
|
}
|
|
};
|
|
# 528 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<>
|
|
struct __copy_move_backward<false, false, random_access_iterator_tag>
|
|
{
|
|
template<typename _BI1, typename _BI2>
|
|
static _BI2
|
|
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
|
|
{
|
|
typename iterator_traits<_BI1>::difference_type __n;
|
|
for (__n = __last - __first; __n > 0; --__n)
|
|
*--__result = *--__last;
|
|
return __result;
|
|
}
|
|
};
|
|
# 558 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<bool _IsMove>
|
|
struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
|
|
{
|
|
template<typename _Tp>
|
|
static _Tp*
|
|
__copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
|
|
{
|
|
const ptrdiff_t _Num = __last - __first;
|
|
if (_Num)
|
|
__builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
|
|
return __result - _Num;
|
|
}
|
|
};
|
|
|
|
template<bool _IsMove, typename _BI1, typename _BI2>
|
|
inline _BI2
|
|
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
|
|
{
|
|
typedef typename iterator_traits<_BI1>::value_type _ValueType1;
|
|
typedef typename iterator_traits<_BI2>::value_type _ValueType2;
|
|
typedef typename iterator_traits<_BI1>::iterator_category _Category;
|
|
const bool __simple = (__is_trivial(_ValueType1)
|
|
&& __is_pointer<_BI1>::__value
|
|
&& __is_pointer<_BI2>::__value
|
|
&& __are_same<_ValueType1, _ValueType2>::__value);
|
|
|
|
return std::__copy_move_backward<_IsMove, __simple,
|
|
_Category>::__copy_move_b(__first,
|
|
__last,
|
|
__result);
|
|
}
|
|
|
|
template<bool _IsMove, typename _BI1, typename _BI2>
|
|
inline _BI2
|
|
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
|
|
{
|
|
return _BI2(std::__copy_move_backward_a<_IsMove>
|
|
(std::__niter_base(__first), std::__niter_base(__last),
|
|
std::__niter_base(__result)));
|
|
}
|
|
# 617 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _BI1, typename _BI2>
|
|
inline _BI2
|
|
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
|
|
(std::__miter_base(__first), std::__miter_base(__last),
|
|
__result));
|
|
}
|
|
# 675 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
|
|
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __value)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
*__first = __value;
|
|
}
|
|
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
|
|
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __value)
|
|
{
|
|
const _Tp __tmp = __value;
|
|
for (; __first != __last; ++__first)
|
|
*__first = __tmp;
|
|
}
|
|
|
|
|
|
template<typename _Tp>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
|
|
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
|
|
{
|
|
const _Tp __tmp = __c;
|
|
__builtin_memset(__first, static_cast<unsigned char>(__tmp),
|
|
__last - __first);
|
|
}
|
|
# 719 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
inline void
|
|
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
|
|
{
|
|
|
|
|
|
|
|
;
|
|
|
|
std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
|
|
__value);
|
|
}
|
|
|
|
template<typename _OutputIterator, typename _Size, typename _Tp>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
|
|
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
|
|
{
|
|
for (__decltype(__n + 0) __niter = __n;
|
|
__niter > 0; --__niter, ++__first)
|
|
*__first = __value;
|
|
return __first;
|
|
}
|
|
|
|
template<typename _OutputIterator, typename _Size, typename _Tp>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
|
|
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
|
|
{
|
|
const _Tp __tmp = __value;
|
|
for (__decltype(__n + 0) __niter = __n;
|
|
__niter > 0; --__niter, ++__first)
|
|
*__first = __tmp;
|
|
return __first;
|
|
}
|
|
|
|
template<typename _Size, typename _Tp>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
|
|
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
|
|
{
|
|
std::__fill_a(__first, __first + __n, __c);
|
|
return __first + __n;
|
|
}
|
|
# 779 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _OI, typename _Size, typename _Tp>
|
|
inline _OI
|
|
fill_n(_OI __first, _Size __n, const _Tp& __value)
|
|
{
|
|
|
|
|
|
|
|
return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
|
|
}
|
|
|
|
template<bool _BoolType>
|
|
struct __equal
|
|
{
|
|
template<typename _II1, typename _II2>
|
|
static bool
|
|
equal(_II1 __first1, _II1 __last1, _II2 __first2)
|
|
{
|
|
for (; __first1 != __last1; ++__first1, ++__first2)
|
|
if (!(*__first1 == *__first2))
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct __equal<true>
|
|
{
|
|
template<typename _Tp>
|
|
static bool
|
|
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
|
|
{
|
|
return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
|
|
* (__last1 - __first1));
|
|
}
|
|
};
|
|
|
|
template<typename _II1, typename _II2>
|
|
inline bool
|
|
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
|
|
{
|
|
typedef typename iterator_traits<_II1>::value_type _ValueType1;
|
|
typedef typename iterator_traits<_II2>::value_type _ValueType2;
|
|
const bool __simple = ((__is_integer<_ValueType1>::__value
|
|
|| __is_pointer<_ValueType1>::__value)
|
|
&& __is_pointer<_II1>::__value
|
|
&& __is_pointer<_II2>::__value
|
|
&& __are_same<_ValueType1, _ValueType2>::__value);
|
|
|
|
return std::__equal<__simple>::equal(__first1, __last1, __first2);
|
|
}
|
|
|
|
|
|
template<typename, typename>
|
|
struct __lc_rai
|
|
{
|
|
template<typename _II1, typename _II2>
|
|
static _II1
|
|
__newlast1(_II1, _II1 __last1, _II2, _II2)
|
|
{ return __last1; }
|
|
|
|
template<typename _II>
|
|
static bool
|
|
__cnd2(_II __first, _II __last)
|
|
{ return __first != __last; }
|
|
};
|
|
|
|
template<>
|
|
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
|
|
{
|
|
template<typename _RAI1, typename _RAI2>
|
|
static _RAI1
|
|
__newlast1(_RAI1 __first1, _RAI1 __last1,
|
|
_RAI2 __first2, _RAI2 __last2)
|
|
{
|
|
const typename iterator_traits<_RAI1>::difference_type
|
|
__diff1 = __last1 - __first1;
|
|
const typename iterator_traits<_RAI2>::difference_type
|
|
__diff2 = __last2 - __first2;
|
|
return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
|
|
}
|
|
|
|
template<typename _RAI>
|
|
static bool
|
|
__cnd2(_RAI, _RAI)
|
|
{ return true; }
|
|
};
|
|
|
|
template<bool _BoolType>
|
|
struct __lexicographical_compare
|
|
{
|
|
template<typename _II1, typename _II2>
|
|
static bool __lc(_II1, _II1, _II2, _II2);
|
|
};
|
|
|
|
template<bool _BoolType>
|
|
template<typename _II1, typename _II2>
|
|
bool
|
|
__lexicographical_compare<_BoolType>::
|
|
__lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
|
|
{
|
|
typedef typename iterator_traits<_II1>::iterator_category _Category1;
|
|
typedef typename iterator_traits<_II2>::iterator_category _Category2;
|
|
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
|
|
|
|
__last1 = __rai_type::__newlast1(__first1, __last1,
|
|
__first2, __last2);
|
|
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
|
|
++__first1, ++__first2)
|
|
{
|
|
if (*__first1 < *__first2)
|
|
return true;
|
|
if (*__first2 < *__first1)
|
|
return false;
|
|
}
|
|
return __first1 == __last1 && __first2 != __last2;
|
|
}
|
|
|
|
template<>
|
|
struct __lexicographical_compare<true>
|
|
{
|
|
template<typename _Tp, typename _Up>
|
|
static bool
|
|
__lc(const _Tp* __first1, const _Tp* __last1,
|
|
const _Up* __first2, const _Up* __last2)
|
|
{
|
|
const size_t __len1 = __last1 - __first1;
|
|
const size_t __len2 = __last2 - __first2;
|
|
const int __result = __builtin_memcmp(__first1, __first2,
|
|
std::min(__len1, __len2));
|
|
return __result != 0 ? __result < 0 : __len1 < __len2;
|
|
}
|
|
};
|
|
|
|
template<typename _II1, typename _II2>
|
|
inline bool
|
|
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
|
|
_II2 __first2, _II2 __last2)
|
|
{
|
|
typedef typename iterator_traits<_II1>::value_type _ValueType1;
|
|
typedef typename iterator_traits<_II2>::value_type _ValueType2;
|
|
const bool __simple =
|
|
(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
|
|
&& !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
|
|
&& !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
|
|
&& __is_pointer<_II1>::__value
|
|
&& __is_pointer<_II2>::__value);
|
|
|
|
return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
|
|
__first2, __last2);
|
|
}
|
|
# 941 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
_ForwardIterator
|
|
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __val)
|
|
{
|
|
|
|
|
|
|
|
|
|
typedef typename iterator_traits<_ForwardIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
_DistanceType __len = std::distance(__first, __last);
|
|
|
|
while (__len > 0)
|
|
{
|
|
_DistanceType __half = __len >> 1;
|
|
_ForwardIterator __middle = __first;
|
|
std::advance(__middle, __half);
|
|
if (*__middle < __val)
|
|
{
|
|
__first = __middle;
|
|
++__first;
|
|
__len = __len - __half - 1;
|
|
}
|
|
else
|
|
__len = __half;
|
|
}
|
|
return __first;
|
|
}
|
|
|
|
|
|
|
|
inline int
|
|
__lg(int __n)
|
|
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
|
|
|
|
inline unsigned
|
|
__lg(unsigned __n)
|
|
{ return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
|
|
|
|
inline long
|
|
__lg(long __n)
|
|
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
|
|
|
|
inline unsigned long
|
|
__lg(unsigned long __n)
|
|
{ return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
|
|
|
|
inline long long
|
|
__lg(long long __n)
|
|
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
|
|
|
|
inline unsigned long long
|
|
__lg(unsigned long long __n)
|
|
{ return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
|
|
|
|
|
|
|
|
|
|
# 1019 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _II1, typename _II2>
|
|
inline bool
|
|
equal(_II1 __first1, _II1 __last1, _II2 __first2)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
return std::__equal_aux(std::__niter_base(__first1),
|
|
std::__niter_base(__last1),
|
|
std::__niter_base(__first2));
|
|
}
|
|
# 1051 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
|
|
inline bool
|
|
equal(_IIter1 __first1, _IIter1 __last1,
|
|
_IIter2 __first2, _BinaryPredicate __binary_pred)
|
|
{
|
|
|
|
|
|
|
|
;
|
|
|
|
for (; __first1 != __last1; ++__first1, ++__first2)
|
|
if (!bool(__binary_pred(*__first1, *__first2)))
|
|
return false;
|
|
return true;
|
|
}
|
|
# 1082 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _II1, typename _II2>
|
|
inline bool
|
|
lexicographical_compare(_II1 __first1, _II1 __last1,
|
|
_II2 __first2, _II2 __last2)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
;
|
|
|
|
return std::__lexicographical_compare_aux(std::__niter_base(__first1),
|
|
std::__niter_base(__last1),
|
|
std::__niter_base(__first2),
|
|
std::__niter_base(__last2));
|
|
}
|
|
# 1118 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _II1, typename _II2, typename _Compare>
|
|
bool
|
|
lexicographical_compare(_II1 __first1, _II1 __last1,
|
|
_II2 __first2, _II2 __last2, _Compare __comp)
|
|
{
|
|
typedef typename iterator_traits<_II1>::iterator_category _Category1;
|
|
typedef typename iterator_traits<_II2>::iterator_category _Category2;
|
|
typedef std::__lc_rai<_Category1, _Category2> __rai_type;
|
|
|
|
|
|
|
|
|
|
;
|
|
;
|
|
|
|
__last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
|
|
for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
|
|
++__first1, ++__first2)
|
|
{
|
|
if (__comp(*__first1, *__first2))
|
|
return true;
|
|
if (__comp(*__first2, *__first1))
|
|
return false;
|
|
}
|
|
return __first1 == __last1 && __first2 != __last2;
|
|
}
|
|
# 1158 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _InputIterator1, typename _InputIterator2>
|
|
pair<_InputIterator1, _InputIterator2>
|
|
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
|
|
_InputIterator2 __first2)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
while (__first1 != __last1 && *__first1 == *__first2)
|
|
{
|
|
++__first1;
|
|
++__first2;
|
|
}
|
|
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
|
|
}
|
|
# 1195 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
|
|
template<typename _InputIterator1, typename _InputIterator2,
|
|
typename _BinaryPredicate>
|
|
pair<_InputIterator1, _InputIterator2>
|
|
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
|
|
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
|
|
{
|
|
|
|
|
|
|
|
;
|
|
|
|
while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
|
|
{
|
|
++__first1;
|
|
++__first2;
|
|
}
|
|
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
|
|
}
|
|
|
|
|
|
}
|
|
# 40 "/usr/include/c++/4.8.2/bits/char_traits.h" 2 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/cwchar" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/cwchar" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/cwchar" 3
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/wchar.h" 1 3 4
|
|
# 45 "/usr/include/c++/4.8.2/cwchar" 2 3
|
|
# 42 "/usr/include/c++/4.8.2/bits/char_traits.h" 2 3
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 57 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
|
|
template<typename _CharT>
|
|
struct _Char_types
|
|
{
|
|
typedef unsigned long int_type;
|
|
typedef std::streampos pos_type;
|
|
typedef std::streamoff off_type;
|
|
typedef std::mbstate_t state_type;
|
|
};
|
|
# 82 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
|
|
template<typename _CharT>
|
|
struct char_traits
|
|
{
|
|
typedef _CharT char_type;
|
|
typedef typename _Char_types<_CharT>::int_type int_type;
|
|
typedef typename _Char_types<_CharT>::pos_type pos_type;
|
|
typedef typename _Char_types<_CharT>::off_type off_type;
|
|
typedef typename _Char_types<_CharT>::state_type state_type;
|
|
|
|
static void
|
|
assign(char_type& __c1, const char_type& __c2)
|
|
{ __c1 = __c2; }
|
|
|
|
static bool
|
|
eq(const char_type& __c1, const char_type& __c2)
|
|
{ return __c1 == __c2; }
|
|
|
|
static bool
|
|
lt(const char_type& __c1, const char_type& __c2)
|
|
{ return __c1 < __c2; }
|
|
|
|
static int
|
|
compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
|
|
|
|
static std::size_t
|
|
length(const char_type* __s);
|
|
|
|
static const char_type*
|
|
find(const char_type* __s, std::size_t __n, const char_type& __a);
|
|
|
|
static char_type*
|
|
move(char_type* __s1, const char_type* __s2, std::size_t __n);
|
|
|
|
static char_type*
|
|
copy(char_type* __s1, const char_type* __s2, std::size_t __n);
|
|
|
|
static char_type*
|
|
assign(char_type* __s, std::size_t __n, char_type __a);
|
|
|
|
static char_type
|
|
to_char_type(const int_type& __c)
|
|
{ return static_cast<char_type>(__c); }
|
|
|
|
static int_type
|
|
to_int_type(const char_type& __c)
|
|
{ return static_cast<int_type>(__c); }
|
|
|
|
static bool
|
|
eq_int_type(const int_type& __c1, const int_type& __c2)
|
|
{ return __c1 == __c2; }
|
|
|
|
static int_type
|
|
eof()
|
|
{ return static_cast<int_type>(-1); }
|
|
|
|
static int_type
|
|
not_eof(const int_type& __c)
|
|
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
|
|
};
|
|
|
|
template<typename _CharT>
|
|
int
|
|
char_traits<_CharT>::
|
|
compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
|
|
{
|
|
for (std::size_t __i = 0; __i < __n; ++__i)
|
|
if (lt(__s1[__i], __s2[__i]))
|
|
return -1;
|
|
else if (lt(__s2[__i], __s1[__i]))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
template<typename _CharT>
|
|
std::size_t
|
|
char_traits<_CharT>::
|
|
length(const char_type* __p)
|
|
{
|
|
std::size_t __i = 0;
|
|
while (!eq(__p[__i], char_type()))
|
|
++__i;
|
|
return __i;
|
|
}
|
|
|
|
template<typename _CharT>
|
|
const typename char_traits<_CharT>::char_type*
|
|
char_traits<_CharT>::
|
|
find(const char_type* __s, std::size_t __n, const char_type& __a)
|
|
{
|
|
for (std::size_t __i = 0; __i < __n; ++__i)
|
|
if (eq(__s[__i], __a))
|
|
return __s + __i;
|
|
return 0;
|
|
}
|
|
|
|
template<typename _CharT>
|
|
typename char_traits<_CharT>::char_type*
|
|
char_traits<_CharT>::
|
|
move(char_type* __s1, const char_type* __s2, std::size_t __n)
|
|
{
|
|
return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
|
|
__n * sizeof(char_type)));
|
|
}
|
|
|
|
template<typename _CharT>
|
|
typename char_traits<_CharT>::char_type*
|
|
char_traits<_CharT>::
|
|
copy(char_type* __s1, const char_type* __s2, std::size_t __n)
|
|
{
|
|
|
|
std::copy(__s2, __s2 + __n, __s1);
|
|
return __s1;
|
|
}
|
|
|
|
template<typename _CharT>
|
|
typename char_traits<_CharT>::char_type*
|
|
char_traits<_CharT>::
|
|
assign(char_type* __s, std::size_t __n, char_type __a)
|
|
{
|
|
|
|
std::fill_n(__s, __n, __a);
|
|
return __s;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 226 "/usr/include/c++/4.8.2/bits/char_traits.h" 3
|
|
template<class _CharT>
|
|
struct char_traits : public __gnu_cxx::char_traits<_CharT>
|
|
{ };
|
|
|
|
|
|
|
|
template<>
|
|
struct char_traits<char>
|
|
{
|
|
typedef char char_type;
|
|
typedef int int_type;
|
|
typedef streampos pos_type;
|
|
typedef streamoff off_type;
|
|
typedef mbstate_t state_type;
|
|
|
|
static void
|
|
assign(char_type& __c1, const char_type& __c2)
|
|
{ __c1 = __c2; }
|
|
|
|
static bool
|
|
eq(const char_type& __c1, const char_type& __c2)
|
|
{ return __c1 == __c2; }
|
|
|
|
static bool
|
|
lt(const char_type& __c1, const char_type& __c2)
|
|
{ return __c1 < __c2; }
|
|
|
|
static int
|
|
compare(const char_type* __s1, const char_type* __s2, size_t __n)
|
|
{ return __builtin_memcmp(__s1, __s2, __n); }
|
|
|
|
static size_t
|
|
length(const char_type* __s)
|
|
{ return __builtin_strlen(__s); }
|
|
|
|
static const char_type*
|
|
find(const char_type* __s, size_t __n, const char_type& __a)
|
|
{ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
|
|
|
|
static char_type*
|
|
move(char_type* __s1, const char_type* __s2, size_t __n)
|
|
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
|
|
|
|
static char_type*
|
|
copy(char_type* __s1, const char_type* __s2, size_t __n)
|
|
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
|
|
|
|
static char_type*
|
|
assign(char_type* __s, size_t __n, char_type __a)
|
|
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
|
|
|
|
static char_type
|
|
to_char_type(const int_type& __c)
|
|
{ return static_cast<char_type>(__c); }
|
|
|
|
|
|
|
|
static int_type
|
|
to_int_type(const char_type& __c)
|
|
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
|
|
|
|
static bool
|
|
eq_int_type(const int_type& __c1, const int_type& __c2)
|
|
{ return __c1 == __c2; }
|
|
|
|
static int_type
|
|
eof()
|
|
{ return static_cast<int_type>(-1); }
|
|
|
|
static int_type
|
|
not_eof(const int_type& __c)
|
|
{ return (__c == eof()) ? 0 : __c; }
|
|
};
|
|
|
|
|
|
|
|
|
|
template<>
|
|
struct char_traits<wchar_t>
|
|
{
|
|
typedef wchar_t char_type;
|
|
typedef wint_t int_type;
|
|
typedef streamoff off_type;
|
|
typedef wstreampos pos_type;
|
|
typedef mbstate_t state_type;
|
|
|
|
static void
|
|
assign(char_type& __c1, const char_type& __c2)
|
|
{ __c1 = __c2; }
|
|
|
|
static bool
|
|
eq(const char_type& __c1, const char_type& __c2)
|
|
{ return __c1 == __c2; }
|
|
|
|
static bool
|
|
lt(const char_type& __c1, const char_type& __c2)
|
|
{ return __c1 < __c2; }
|
|
|
|
static int
|
|
compare(const char_type* __s1, const char_type* __s2, size_t __n)
|
|
{ return wmemcmp(__s1, __s2, __n); }
|
|
|
|
static size_t
|
|
length(const char_type* __s)
|
|
{ return wcslen(__s); }
|
|
|
|
static const char_type*
|
|
find(const char_type* __s, size_t __n, const char_type& __a)
|
|
{ return wmemchr(__s, __a, __n); }
|
|
|
|
static char_type*
|
|
move(char_type* __s1, const char_type* __s2, size_t __n)
|
|
{ return wmemmove(__s1, __s2, __n); }
|
|
|
|
static char_type*
|
|
copy(char_type* __s1, const char_type* __s2, size_t __n)
|
|
{ return wmemcpy(__s1, __s2, __n); }
|
|
|
|
static char_type*
|
|
assign(char_type* __s, size_t __n, char_type __a)
|
|
{ return wmemset(__s, __a, __n); }
|
|
|
|
static char_type
|
|
to_char_type(const int_type& __c)
|
|
{ return char_type(__c); }
|
|
|
|
static int_type
|
|
to_int_type(const char_type& __c)
|
|
{ return int_type(__c); }
|
|
|
|
static bool
|
|
eq_int_type(const int_type& __c1, const int_type& __c2)
|
|
{ return __c1 == __c2; }
|
|
|
|
static int_type
|
|
eof()
|
|
{ return static_cast<int_type>((0xffffffffu)); }
|
|
|
|
static int_type
|
|
not_eof(const int_type& __c)
|
|
{ return eq_int_type(__c, eof()) ? 0 : __c; }
|
|
};
|
|
|
|
|
|
|
|
}
|
|
# 41 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/localefwd.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/clocale" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/clocale" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/clocale" 3
|
|
|
|
|
|
# 1 "/usr/include/locale.h" 1 3 4
|
|
# 29 "/usr/include/locale.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 30 "/usr/include/locale.h" 2 3 4
|
|
# 1 "/usr/include/bits/locale.h" 1 3 4
|
|
# 31 "/usr/include/locale.h" 2 3 4
|
|
|
|
extern "C" {
|
|
# 51 "/usr/include/locale.h" 3 4
|
|
|
|
|
|
|
|
struct lconv
|
|
{
|
|
|
|
|
|
char *decimal_point;
|
|
char *thousands_sep;
|
|
|
|
|
|
|
|
|
|
|
|
char *grouping;
|
|
|
|
|
|
|
|
|
|
|
|
char *int_curr_symbol;
|
|
char *currency_symbol;
|
|
char *mon_decimal_point;
|
|
char *mon_thousands_sep;
|
|
char *mon_grouping;
|
|
char *positive_sign;
|
|
char *negative_sign;
|
|
char int_frac_digits;
|
|
char frac_digits;
|
|
|
|
char p_cs_precedes;
|
|
|
|
char p_sep_by_space;
|
|
|
|
char n_cs_precedes;
|
|
|
|
char n_sep_by_space;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
char p_sign_posn;
|
|
char n_sign_posn;
|
|
|
|
|
|
char int_p_cs_precedes;
|
|
|
|
char int_p_sep_by_space;
|
|
|
|
char int_n_cs_precedes;
|
|
|
|
char int_n_sep_by_space;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
char int_p_sign_posn;
|
|
char int_n_sign_posn;
|
|
# 121 "/usr/include/locale.h" 3 4
|
|
};
|
|
|
|
|
|
|
|
extern char *setlocale (int __category, const char *__locale) throw ();
|
|
|
|
|
|
extern struct lconv *localeconv (void) throw ();
|
|
|
|
|
|
# 152 "/usr/include/locale.h" 3 4
|
|
extern __locale_t newlocale (int __category_mask, const char *__locale,
|
|
__locale_t __base) throw ();
|
|
# 187 "/usr/include/locale.h" 3 4
|
|
extern __locale_t duplocale (__locale_t __dataset) throw ();
|
|
|
|
|
|
|
|
extern void freelocale (__locale_t __dataset) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __locale_t uselocale (__locale_t __dataset) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
# 43 "/usr/include/c++/4.8.2/clocale" 2 3
|
|
# 51 "/usr/include/c++/4.8.2/clocale" 3
|
|
namespace std
|
|
{
|
|
using ::lconv;
|
|
using ::setlocale;
|
|
using ::localeconv;
|
|
}
|
|
# 42 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 2 3
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
extern "C" __typeof(uselocale) __uselocale;
|
|
|
|
|
|
}
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
typedef __locale_t __c_locale;
|
|
|
|
|
|
|
|
|
|
|
|
inline int
|
|
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
|
|
char* __out,
|
|
const int __size __attribute__ ((__unused__)),
|
|
const char* __fmt, ...)
|
|
{
|
|
|
|
__c_locale __old = __gnu_cxx::__uselocale(__cloc);
|
|
# 88 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
|
|
__builtin_va_list __args;
|
|
__builtin_va_start(__args, __fmt);
|
|
|
|
|
|
const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
|
|
|
|
|
|
|
|
|
|
__builtin_va_end(__args);
|
|
|
|
|
|
__gnu_cxx::__uselocale(__old);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return __ret;
|
|
}
|
|
|
|
|
|
}
|
|
# 41 "/usr/include/c++/4.8.2/bits/localefwd.h" 2 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/cctype" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/cctype" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/cctype" 3
|
|
|
|
|
|
# 1 "/usr/include/ctype.h" 1 3 4
|
|
# 27 "/usr/include/ctype.h" 3 4
|
|
# 1 "/usr/include/bits/types.h" 1 3 4
|
|
# 27 "/usr/include/bits/types.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 28 "/usr/include/bits/types.h" 2 3 4
|
|
|
|
|
|
typedef unsigned char __u_char;
|
|
typedef unsigned short int __u_short;
|
|
typedef unsigned int __u_int;
|
|
typedef unsigned long int __u_long;
|
|
|
|
|
|
typedef signed char __int8_t;
|
|
typedef unsigned char __uint8_t;
|
|
typedef signed short int __int16_t;
|
|
typedef unsigned short int __uint16_t;
|
|
typedef signed int __int32_t;
|
|
typedef unsigned int __uint32_t;
|
|
|
|
typedef signed long int __int64_t;
|
|
typedef unsigned long int __uint64_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef long int __quad_t;
|
|
typedef unsigned long int __u_quad_t;
|
|
# 130 "/usr/include/bits/types.h" 3 4
|
|
# 1 "/usr/include/bits/typesizes.h" 1 3 4
|
|
# 131 "/usr/include/bits/types.h" 2 3 4
|
|
|
|
|
|
typedef unsigned long int __dev_t;
|
|
typedef unsigned int __uid_t;
|
|
typedef unsigned int __gid_t;
|
|
typedef unsigned long int __ino_t;
|
|
typedef unsigned long int __ino64_t;
|
|
typedef unsigned int __mode_t;
|
|
typedef unsigned long int __nlink_t;
|
|
typedef long int __off_t;
|
|
typedef long int __off64_t;
|
|
typedef int __pid_t;
|
|
typedef struct { int __val[2]; } __fsid_t;
|
|
typedef long int __clock_t;
|
|
typedef unsigned long int __rlim_t;
|
|
typedef unsigned long int __rlim64_t;
|
|
typedef unsigned int __id_t;
|
|
typedef long int __time_t;
|
|
typedef unsigned int __useconds_t;
|
|
typedef long int __suseconds_t;
|
|
|
|
typedef int __daddr_t;
|
|
typedef int __key_t;
|
|
|
|
|
|
typedef int __clockid_t;
|
|
|
|
|
|
typedef void * __timer_t;
|
|
|
|
|
|
typedef long int __blksize_t;
|
|
|
|
|
|
|
|
|
|
typedef long int __blkcnt_t;
|
|
typedef long int __blkcnt64_t;
|
|
|
|
|
|
typedef unsigned long int __fsblkcnt_t;
|
|
typedef unsigned long int __fsblkcnt64_t;
|
|
|
|
|
|
typedef unsigned long int __fsfilcnt_t;
|
|
typedef unsigned long int __fsfilcnt64_t;
|
|
|
|
|
|
typedef long int __fsword_t;
|
|
|
|
typedef long int __ssize_t;
|
|
|
|
|
|
typedef long int __syscall_slong_t;
|
|
|
|
typedef unsigned long int __syscall_ulong_t;
|
|
|
|
|
|
|
|
typedef __off64_t __loff_t;
|
|
typedef __quad_t *__qaddr_t;
|
|
typedef char *__caddr_t;
|
|
|
|
|
|
typedef long int __intptr_t;
|
|
|
|
|
|
typedef unsigned int __socklen_t;
|
|
# 28 "/usr/include/ctype.h" 2 3 4
|
|
|
|
extern "C" {
|
|
# 40 "/usr/include/ctype.h" 3 4
|
|
# 1 "/usr/include/endian.h" 1 3 4
|
|
# 36 "/usr/include/endian.h" 3 4
|
|
# 1 "/usr/include/bits/endian.h" 1 3 4
|
|
# 37 "/usr/include/endian.h" 2 3 4
|
|
# 60 "/usr/include/endian.h" 3 4
|
|
# 1 "/usr/include/bits/byteswap.h" 1 3 4
|
|
# 28 "/usr/include/bits/byteswap.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 29 "/usr/include/bits/byteswap.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/byteswap-16.h" 1 3 4
|
|
# 36 "/usr/include/bits/byteswap.h" 2 3 4
|
|
# 44 "/usr/include/bits/byteswap.h" 3 4
|
|
static __inline unsigned int
|
|
__bswap_32 (unsigned int __bsx)
|
|
{
|
|
return __builtin_bswap32 (__bsx);
|
|
}
|
|
# 108 "/usr/include/bits/byteswap.h" 3 4
|
|
static __inline __uint64_t
|
|
__bswap_64 (__uint64_t __bsx)
|
|
{
|
|
return __builtin_bswap64 (__bsx);
|
|
}
|
|
# 61 "/usr/include/endian.h" 2 3 4
|
|
# 41 "/usr/include/ctype.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
|
|
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
|
|
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
|
|
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
|
|
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
|
|
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
|
|
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
|
|
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
|
|
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
|
|
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
|
|
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
|
|
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
|
|
};
|
|
# 80 "/usr/include/ctype.h" 3 4
|
|
extern const unsigned short int **__ctype_b_loc (void)
|
|
throw () __attribute__ ((__const__));
|
|
extern const __int32_t **__ctype_tolower_loc (void)
|
|
throw () __attribute__ ((__const__));
|
|
extern const __int32_t **__ctype_toupper_loc (void)
|
|
throw () __attribute__ ((__const__));
|
|
# 105 "/usr/include/ctype.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int isalnum (int) throw ();
|
|
extern int isalpha (int) throw ();
|
|
extern int iscntrl (int) throw ();
|
|
extern int isdigit (int) throw ();
|
|
extern int islower (int) throw ();
|
|
extern int isgraph (int) throw ();
|
|
extern int isprint (int) throw ();
|
|
extern int ispunct (int) throw ();
|
|
extern int isspace (int) throw ();
|
|
extern int isupper (int) throw ();
|
|
extern int isxdigit (int) throw ();
|
|
|
|
|
|
|
|
extern int tolower (int __c) throw ();
|
|
|
|
|
|
extern int toupper (int __c) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int isblank (int) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int isctype (int __c, int __mask) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int isascii (int __c) throw ();
|
|
|
|
|
|
|
|
extern int toascii (int __c) throw ();
|
|
|
|
|
|
|
|
extern int _toupper (int) throw ();
|
|
extern int _tolower (int) throw ();
|
|
# 272 "/usr/include/ctype.h" 3 4
|
|
extern int isalnum_l (int, __locale_t) throw ();
|
|
extern int isalpha_l (int, __locale_t) throw ();
|
|
extern int iscntrl_l (int, __locale_t) throw ();
|
|
extern int isdigit_l (int, __locale_t) throw ();
|
|
extern int islower_l (int, __locale_t) throw ();
|
|
extern int isgraph_l (int, __locale_t) throw ();
|
|
extern int isprint_l (int, __locale_t) throw ();
|
|
extern int ispunct_l (int, __locale_t) throw ();
|
|
extern int isspace_l (int, __locale_t) throw ();
|
|
extern int isupper_l (int, __locale_t) throw ();
|
|
extern int isxdigit_l (int, __locale_t) throw ();
|
|
|
|
extern int isblank_l (int, __locale_t) throw ();
|
|
|
|
|
|
|
|
extern int __tolower_l (int __c, __locale_t __l) throw ();
|
|
extern int tolower_l (int __c, __locale_t __l) throw ();
|
|
|
|
|
|
extern int __toupper_l (int __c, __locale_t __l) throw ();
|
|
extern int toupper_l (int __c, __locale_t __l) throw ();
|
|
# 348 "/usr/include/ctype.h" 3 4
|
|
}
|
|
# 43 "/usr/include/c++/4.8.2/cctype" 2 3
|
|
# 62 "/usr/include/c++/4.8.2/cctype" 3
|
|
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;
|
|
}
|
|
# 43 "/usr/include/c++/4.8.2/bits/localefwd.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 55 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
|
|
class locale;
|
|
|
|
template<typename _Facet>
|
|
bool
|
|
has_facet(const locale&) throw();
|
|
|
|
template<typename _Facet>
|
|
const _Facet&
|
|
use_facet(const locale&);
|
|
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isspace(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isprint(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
iscntrl(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isupper(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
islower(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isalpha(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isdigit(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
ispunct(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isxdigit(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isalnum(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
bool
|
|
isgraph(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
_CharT
|
|
toupper(_CharT, const locale&);
|
|
|
|
template<typename _CharT>
|
|
_CharT
|
|
tolower(_CharT, const locale&);
|
|
|
|
|
|
class ctype_base;
|
|
template<typename _CharT>
|
|
class ctype;
|
|
template<> class ctype<char>;
|
|
|
|
template<> class ctype<wchar_t>;
|
|
|
|
template<typename _CharT>
|
|
class ctype_byname;
|
|
|
|
|
|
class codecvt_base;
|
|
template<typename _InternT, typename _ExternT, typename _StateT>
|
|
class codecvt;
|
|
template<> class codecvt<char, char, mbstate_t>;
|
|
|
|
template<> class codecvt<wchar_t, char, mbstate_t>;
|
|
|
|
template<typename _InternT, typename _ExternT, typename _StateT>
|
|
class codecvt_byname;
|
|
|
|
|
|
|
|
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
|
class num_get;
|
|
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
|
class num_put;
|
|
|
|
template<typename _CharT> class numpunct;
|
|
template<typename _CharT> class numpunct_byname;
|
|
|
|
|
|
template<typename _CharT>
|
|
class collate;
|
|
template<typename _CharT> class
|
|
collate_byname;
|
|
|
|
|
|
class time_base;
|
|
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
|
class time_get;
|
|
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
|
class time_get_byname;
|
|
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
|
class time_put;
|
|
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
|
class time_put_byname;
|
|
|
|
|
|
class money_base;
|
|
|
|
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
|
|
class money_get;
|
|
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
|
|
class money_put;
|
|
|
|
template<typename _CharT, bool _Intl = false>
|
|
class moneypunct;
|
|
template<typename _CharT, bool _Intl = false>
|
|
class moneypunct_byname;
|
|
|
|
|
|
class messages_base;
|
|
template<typename _CharT>
|
|
class messages;
|
|
template<typename _CharT>
|
|
class messages_byname;
|
|
|
|
|
|
}
|
|
# 42 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/ios_base.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/ext/atomicity.h" 1 3
|
|
# 32 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
|
|
|
|
# 33 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 1 3
|
|
# 30 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 3
|
|
#pragma GCC visibility push(default)
|
|
# 148 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 1 3
|
|
# 35 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
# 1 "/usr/include/pthread.h" 1 3 4
|
|
# 23 "/usr/include/pthread.h" 3 4
|
|
# 1 "/usr/include/sched.h" 1 3 4
|
|
# 29 "/usr/include/sched.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 30 "/usr/include/sched.h" 2 3 4
|
|
|
|
|
|
|
|
# 1 "/usr/include/time.h" 1 3 4
|
|
# 73 "/usr/include/time.h" 3 4
|
|
|
|
|
|
typedef __time_t time_t;
|
|
|
|
|
|
|
|
# 120 "/usr/include/time.h" 3 4
|
|
struct timespec
|
|
{
|
|
__time_t tv_sec;
|
|
__syscall_slong_t tv_nsec;
|
|
};
|
|
# 34 "/usr/include/sched.h" 2 3 4
|
|
|
|
|
|
typedef __pid_t pid_t;
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/sched.h" 1 3 4
|
|
# 73 "/usr/include/bits/sched.h" 3 4
|
|
struct sched_param
|
|
{
|
|
int __sched_priority;
|
|
};
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
|
|
int __flags, void *__arg, ...) throw ();
|
|
|
|
|
|
extern int unshare (int __flags) throw ();
|
|
|
|
|
|
extern int sched_getcpu (void) throw ();
|
|
|
|
|
|
extern int setns (int __fd, int __nstype) throw ();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct __sched_param
|
|
{
|
|
int __sched_priority;
|
|
};
|
|
# 119 "/usr/include/bits/sched.h" 3 4
|
|
typedef unsigned long int __cpu_mask;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
|
|
} cpu_set_t;
|
|
# 202 "/usr/include/bits/sched.h" 3 4
|
|
extern "C" {
|
|
|
|
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
|
|
throw ();
|
|
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
|
|
extern void __sched_cpufree (cpu_set_t *__set) throw ();
|
|
|
|
}
|
|
# 43 "/usr/include/sched.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
|
|
throw ();
|
|
|
|
|
|
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
|
|
|
|
|
|
extern int sched_setscheduler (__pid_t __pid, int __policy,
|
|
const struct sched_param *__param) throw ();
|
|
|
|
|
|
extern int sched_getscheduler (__pid_t __pid) throw ();
|
|
|
|
|
|
extern int sched_yield (void) throw ();
|
|
|
|
|
|
extern int sched_get_priority_max (int __algorithm) throw ();
|
|
|
|
|
|
extern int sched_get_priority_min (int __algorithm) throw ();
|
|
|
|
|
|
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
|
|
# 117 "/usr/include/sched.h" 3 4
|
|
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
|
|
const cpu_set_t *__cpuset) throw ();
|
|
|
|
|
|
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
|
|
cpu_set_t *__cpuset) throw ();
|
|
|
|
|
|
}
|
|
# 24 "/usr/include/pthread.h" 2 3 4
|
|
# 1 "/usr/include/time.h" 1 3 4
|
|
# 29 "/usr/include/time.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 38 "/usr/include/time.h" 2 3 4
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/time.h" 1 3 4
|
|
# 30 "/usr/include/bits/time.h" 3 4
|
|
struct timeval
|
|
{
|
|
__time_t tv_sec;
|
|
__suseconds_t tv_usec;
|
|
};
|
|
# 88 "/usr/include/bits/time.h" 3 4
|
|
# 1 "/usr/include/bits/timex.h" 1 3 4
|
|
# 25 "/usr/include/bits/timex.h" 3 4
|
|
struct timex
|
|
{
|
|
unsigned int modes;
|
|
__syscall_slong_t offset;
|
|
__syscall_slong_t freq;
|
|
__syscall_slong_t maxerror;
|
|
__syscall_slong_t esterror;
|
|
int status;
|
|
__syscall_slong_t constant;
|
|
__syscall_slong_t precision;
|
|
__syscall_slong_t tolerance;
|
|
struct timeval time;
|
|
__syscall_slong_t tick;
|
|
__syscall_slong_t ppsfreq;
|
|
__syscall_slong_t jitter;
|
|
int shift;
|
|
__syscall_slong_t stabil;
|
|
__syscall_slong_t jitcnt;
|
|
__syscall_slong_t calcnt;
|
|
__syscall_slong_t errcnt;
|
|
__syscall_slong_t stbcnt;
|
|
|
|
int tai;
|
|
|
|
|
|
int :32; int :32; int :32; int :32;
|
|
int :32; int :32; int :32; int :32;
|
|
int :32; int :32; int :32;
|
|
};
|
|
# 89 "/usr/include/bits/time.h" 2 3 4
|
|
|
|
extern "C" {
|
|
|
|
|
|
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
|
|
|
|
}
|
|
# 42 "/usr/include/time.h" 2 3 4
|
|
# 57 "/usr/include/time.h" 3 4
|
|
|
|
|
|
typedef __clock_t clock_t;
|
|
|
|
|
|
|
|
# 91 "/usr/include/time.h" 3 4
|
|
typedef __clockid_t clockid_t;
|
|
# 103 "/usr/include/time.h" 3 4
|
|
typedef __timer_t timer_t;
|
|
# 131 "/usr/include/time.h" 3 4
|
|
|
|
|
|
struct tm
|
|
{
|
|
int tm_sec;
|
|
int tm_min;
|
|
int tm_hour;
|
|
int tm_mday;
|
|
int tm_mon;
|
|
int tm_year;
|
|
int tm_wday;
|
|
int tm_yday;
|
|
int tm_isdst;
|
|
|
|
|
|
long int tm_gmtoff;
|
|
const char *tm_zone;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct itimerspec
|
|
{
|
|
struct timespec it_interval;
|
|
struct timespec it_value;
|
|
};
|
|
|
|
|
|
struct sigevent;
|
|
# 186 "/usr/include/time.h" 3 4
|
|
|
|
|
|
|
|
extern clock_t clock (void) throw ();
|
|
|
|
|
|
extern time_t time (time_t *__timer) throw ();
|
|
|
|
|
|
extern double difftime (time_t __time1, time_t __time0)
|
|
throw () __attribute__ ((__const__));
|
|
|
|
|
|
extern time_t mktime (struct tm *__tp) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t strftime (char *__restrict __s, size_t __maxsize,
|
|
const char *__restrict __format,
|
|
const struct tm *__restrict __tp) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strptime (const char *__restrict __s,
|
|
const char *__restrict __fmt, struct tm *__tp)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
|
|
const char *__restrict __format,
|
|
const struct tm *__restrict __tp,
|
|
__locale_t __loc) throw ();
|
|
|
|
|
|
|
|
extern char *strptime_l (const char *__restrict __s,
|
|
const char *__restrict __fmt, struct tm *__tp,
|
|
__locale_t __loc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern struct tm *gmtime (const time_t *__timer) throw ();
|
|
|
|
|
|
|
|
extern struct tm *localtime (const time_t *__timer) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern struct tm *gmtime_r (const time_t *__restrict __timer,
|
|
struct tm *__restrict __tp) throw ();
|
|
|
|
|
|
|
|
extern struct tm *localtime_r (const time_t *__restrict __timer,
|
|
struct tm *__restrict __tp) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern char *asctime (const struct tm *__tp) throw ();
|
|
|
|
|
|
extern char *ctime (const time_t *__timer) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *asctime_r (const struct tm *__restrict __tp,
|
|
char *__restrict __buf) throw ();
|
|
|
|
|
|
extern char *ctime_r (const time_t *__restrict __timer,
|
|
char *__restrict __buf) throw ();
|
|
|
|
|
|
|
|
|
|
extern char *__tzname[2];
|
|
extern int __daylight;
|
|
extern long int __timezone;
|
|
|
|
|
|
|
|
|
|
extern char *tzname[2];
|
|
|
|
|
|
|
|
extern void tzset (void) throw ();
|
|
|
|
|
|
|
|
extern int daylight;
|
|
extern long int timezone;
|
|
|
|
|
|
|
|
|
|
|
|
extern int stime (const time_t *__when) throw ();
|
|
# 319 "/usr/include/time.h" 3 4
|
|
extern time_t timegm (struct tm *__tp) throw ();
|
|
|
|
|
|
extern time_t timelocal (struct tm *__tp) throw ();
|
|
|
|
|
|
extern int dysize (int __year) throw () __attribute__ ((__const__));
|
|
# 334 "/usr/include/time.h" 3 4
|
|
extern int nanosleep (const struct timespec *__requested_time,
|
|
struct timespec *__remaining);
|
|
|
|
|
|
|
|
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
|
|
|
|
|
|
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
|
|
|
|
|
|
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
|
|
const struct timespec *__req,
|
|
struct timespec *__rem);
|
|
|
|
|
|
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
|
|
|
|
|
|
|
|
|
|
extern int timer_create (clockid_t __clock_id,
|
|
struct sigevent *__restrict __evp,
|
|
timer_t *__restrict __timerid) throw ();
|
|
|
|
|
|
extern int timer_delete (timer_t __timerid) throw ();
|
|
|
|
|
|
extern int timer_settime (timer_t __timerid, int __flags,
|
|
const struct itimerspec *__restrict __value,
|
|
struct itimerspec *__restrict __ovalue) throw ();
|
|
|
|
|
|
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
|
|
throw ();
|
|
|
|
|
|
extern int timer_getoverrun (timer_t __timerid) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int timespec_get (struct timespec *__ts, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
# 403 "/usr/include/time.h" 3 4
|
|
extern int getdate_err;
|
|
# 412 "/usr/include/time.h" 3 4
|
|
extern struct tm *getdate (const char *__string);
|
|
# 426 "/usr/include/time.h" 3 4
|
|
extern int getdate_r (const char *__restrict __string,
|
|
struct tm *__restrict __resbufp);
|
|
|
|
|
|
}
|
|
# 25 "/usr/include/pthread.h" 2 3 4
|
|
|
|
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
|
|
# 21 "/usr/include/bits/pthreadtypes.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
|
|
# 60 "/usr/include/bits/pthreadtypes.h" 3 4
|
|
typedef unsigned long int pthread_t;
|
|
|
|
|
|
union pthread_attr_t
|
|
{
|
|
char __size[56];
|
|
long int __align;
|
|
};
|
|
|
|
typedef union pthread_attr_t pthread_attr_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct __pthread_internal_list
|
|
{
|
|
struct __pthread_internal_list *__prev;
|
|
struct __pthread_internal_list *__next;
|
|
} __pthread_list_t;
|
|
# 90 "/usr/include/bits/pthreadtypes.h" 3 4
|
|
typedef union
|
|
{
|
|
struct __pthread_mutex_s
|
|
{
|
|
int __lock;
|
|
unsigned int __count;
|
|
int __owner;
|
|
|
|
unsigned int __nusers;
|
|
|
|
|
|
|
|
int __kind;
|
|
|
|
short __spins;
|
|
short __elision;
|
|
__pthread_list_t __list;
|
|
# 125 "/usr/include/bits/pthreadtypes.h" 3 4
|
|
} __data;
|
|
char __size[40];
|
|
long int __align;
|
|
} pthread_mutex_t;
|
|
|
|
typedef union
|
|
{
|
|
char __size[4];
|
|
int __align;
|
|
} pthread_mutexattr_t;
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
struct
|
|
{
|
|
int __lock;
|
|
unsigned int __futex;
|
|
__extension__ unsigned long long int __total_seq;
|
|
__extension__ unsigned long long int __wakeup_seq;
|
|
__extension__ unsigned long long int __woken_seq;
|
|
void *__mutex;
|
|
unsigned int __nwaiters;
|
|
unsigned int __broadcast_seq;
|
|
} __data;
|
|
char __size[48];
|
|
__extension__ long long int __align;
|
|
} pthread_cond_t;
|
|
|
|
typedef union
|
|
{
|
|
char __size[4];
|
|
int __align;
|
|
} pthread_condattr_t;
|
|
|
|
|
|
|
|
typedef unsigned int pthread_key_t;
|
|
|
|
|
|
|
|
typedef int pthread_once_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
|
|
struct
|
|
{
|
|
int __lock;
|
|
unsigned int __nr_readers;
|
|
unsigned int __readers_wakeup;
|
|
unsigned int __writer_wakeup;
|
|
unsigned int __nr_readers_queued;
|
|
unsigned int __nr_writers_queued;
|
|
int __writer;
|
|
int __shared;
|
|
unsigned long int __pad1;
|
|
unsigned long int __pad2;
|
|
|
|
|
|
unsigned int __flags;
|
|
|
|
} __data;
|
|
# 212 "/usr/include/bits/pthreadtypes.h" 3 4
|
|
char __size[56];
|
|
long int __align;
|
|
} pthread_rwlock_t;
|
|
|
|
typedef union
|
|
{
|
|
char __size[8];
|
|
long int __align;
|
|
} pthread_rwlockattr_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef volatile int pthread_spinlock_t;
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
char __size[32];
|
|
long int __align;
|
|
} pthread_barrier_t;
|
|
|
|
typedef union
|
|
{
|
|
char __size[4];
|
|
int __align;
|
|
} pthread_barrierattr_t;
|
|
# 27 "/usr/include/pthread.h" 2 3 4
|
|
# 1 "/usr/include/bits/setjmp.h" 1 3 4
|
|
# 26 "/usr/include/bits/setjmp.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 27 "/usr/include/bits/setjmp.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
typedef long int __jmp_buf[8];
|
|
# 28 "/usr/include/pthread.h" 2 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 29 "/usr/include/pthread.h" 2 3 4
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_CREATE_JOINABLE,
|
|
|
|
PTHREAD_CREATE_DETACHED
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_MUTEX_TIMED_NP,
|
|
PTHREAD_MUTEX_RECURSIVE_NP,
|
|
PTHREAD_MUTEX_ERRORCHECK_NP,
|
|
PTHREAD_MUTEX_ADAPTIVE_NP
|
|
|
|
,
|
|
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
|
|
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
|
|
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
|
|
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
|
|
|
|
|
|
|
|
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_MUTEX_STALLED,
|
|
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
|
|
PTHREAD_MUTEX_ROBUST,
|
|
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_PRIO_NONE,
|
|
PTHREAD_PRIO_INHERIT,
|
|
PTHREAD_PRIO_PROTECT
|
|
};
|
|
# 116 "/usr/include/pthread.h" 3 4
|
|
enum
|
|
{
|
|
PTHREAD_RWLOCK_PREFER_READER_NP,
|
|
PTHREAD_RWLOCK_PREFER_WRITER_NP,
|
|
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
|
|
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
|
|
};
|
|
# 157 "/usr/include/pthread.h" 3 4
|
|
enum
|
|
{
|
|
PTHREAD_INHERIT_SCHED,
|
|
|
|
PTHREAD_EXPLICIT_SCHED
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_SCOPE_SYSTEM,
|
|
|
|
PTHREAD_SCOPE_PROCESS
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_PROCESS_PRIVATE,
|
|
|
|
PTHREAD_PROCESS_SHARED
|
|
|
|
};
|
|
# 192 "/usr/include/pthread.h" 3 4
|
|
struct _pthread_cleanup_buffer
|
|
{
|
|
void (*__routine) (void *);
|
|
void *__arg;
|
|
int __canceltype;
|
|
struct _pthread_cleanup_buffer *__prev;
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
PTHREAD_CANCEL_ENABLE,
|
|
|
|
PTHREAD_CANCEL_DISABLE
|
|
|
|
};
|
|
enum
|
|
{
|
|
PTHREAD_CANCEL_DEFERRED,
|
|
|
|
PTHREAD_CANCEL_ASYNCHRONOUS
|
|
|
|
};
|
|
# 230 "/usr/include/pthread.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
extern int pthread_create (pthread_t *__restrict __newthread,
|
|
const pthread_attr_t *__restrict __attr,
|
|
void *(*__start_routine) (void *),
|
|
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
|
|
|
|
|
|
|
|
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_join (pthread_t __th, void **__thread_return);
|
|
|
|
|
|
|
|
|
|
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
|
|
const struct timespec *__abstime);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_detach (pthread_t __th) throw ();
|
|
|
|
|
|
|
|
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
|
|
|
|
|
|
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
|
|
throw () __attribute__ ((__const__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_attr_destroy (pthread_attr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
|
|
int *__detachstate)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
|
|
int __detachstate)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
|
|
size_t *__guardsize)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
|
|
size_t __guardsize)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
|
|
struct sched_param *__restrict __param)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
|
|
const struct sched_param *__restrict
|
|
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
|
|
__attr, int *__restrict __policy)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
|
|
__attr, int *__restrict __inherit)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
|
|
int __inherit)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
|
|
int *__restrict __scope)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
|
|
__attr, void **__restrict __stackaddr)
|
|
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
|
|
void *__stackaddr)
|
|
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
|
|
|
|
|
|
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
|
|
__attr, size_t *__restrict __stacksize)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
|
|
size_t __stacksize)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
|
|
void **__restrict __stackaddr,
|
|
size_t *__restrict __stacksize)
|
|
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
|
|
|
|
|
|
|
|
|
|
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
|
|
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
|
|
size_t __cpusetsize,
|
|
const cpu_set_t *__cpuset)
|
|
throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
|
|
|
|
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
|
|
size_t __cpusetsize,
|
|
cpu_set_t *__cpuset)
|
|
throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
|
|
const struct sched_param *__param)
|
|
throw () __attribute__ ((__nonnull__ (3)));
|
|
|
|
|
|
extern int pthread_getschedparam (pthread_t __target_thread,
|
|
int *__restrict __policy,
|
|
struct sched_param *__restrict __param)
|
|
throw () __attribute__ ((__nonnull__ (2, 3)));
|
|
|
|
|
|
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
|
|
size_t __buflen)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_getconcurrency (void) throw ();
|
|
|
|
|
|
extern int pthread_setconcurrency (int __level) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_yield (void) throw ();
|
|
|
|
|
|
|
|
|
|
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
|
|
const cpu_set_t *__cpuset)
|
|
throw () __attribute__ ((__nonnull__ (3)));
|
|
|
|
|
|
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
|
|
cpu_set_t *__cpuset)
|
|
throw () __attribute__ ((__nonnull__ (3)));
|
|
# 488 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_once (pthread_once_t *__once_control,
|
|
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
|
|
# 500 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_setcancelstate (int __state, int *__oldstate);
|
|
|
|
|
|
|
|
extern int pthread_setcanceltype (int __type, int *__oldtype);
|
|
|
|
|
|
extern int pthread_cancel (pthread_t __th);
|
|
|
|
|
|
|
|
|
|
extern void pthread_testcancel (void);
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
__jmp_buf __cancel_jmp_buf;
|
|
int __mask_was_saved;
|
|
} __cancel_jmp_buf[1];
|
|
void *__pad[4];
|
|
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
|
|
# 534 "/usr/include/pthread.h" 3 4
|
|
struct __pthread_cleanup_frame
|
|
{
|
|
void (*__cancel_routine) (void *);
|
|
void *__cancel_arg;
|
|
int __do_it;
|
|
int __cancel_type;
|
|
};
|
|
|
|
|
|
|
|
|
|
class __pthread_cleanup_class
|
|
{
|
|
void (*__cancel_routine) (void *);
|
|
void *__cancel_arg;
|
|
int __do_it;
|
|
int __cancel_type;
|
|
|
|
public:
|
|
__pthread_cleanup_class (void (*__fct) (void *), void *__arg)
|
|
: __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
|
|
~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
|
|
void __setdoit (int __newval) { __do_it = __newval; }
|
|
void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
|
|
&__cancel_type); }
|
|
void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
|
|
};
|
|
# 736 "/usr/include/pthread.h" 3 4
|
|
struct __jmp_buf_tag;
|
|
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
|
|
const pthread_mutexattr_t *__mutexattr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
|
|
const struct timespec *__restrict
|
|
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
|
|
__restrict __mutex,
|
|
int *__restrict __prioceiling)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
|
|
int __prioceiling,
|
|
int *__restrict __old_ceiling)
|
|
throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
|
|
|
|
|
|
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
# 800 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
|
|
int __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
|
|
__attr, int *__restrict __kind)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __protocol)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
|
|
int __protocol)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __prioceiling)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
|
|
int __prioceiling)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
|
|
int *__robustness)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
|
|
int *__robustness)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
|
|
int __robustness)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
|
|
int __robustness)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
# 882 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
|
|
const pthread_rwlockattr_t *__restrict
|
|
__attr) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
|
|
const struct timespec *__restrict
|
|
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
|
|
const struct timespec *__restrict
|
|
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
|
|
int __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __pref)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
|
|
int __pref) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
|
|
const pthread_condattr_t *__restrict __cond_attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_cond_destroy (pthread_cond_t *__cond)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_cond_signal (pthread_cond_t *__cond)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
|
|
pthread_mutex_t *__restrict __mutex)
|
|
__attribute__ ((__nonnull__ (1, 2)));
|
|
# 994 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
|
|
pthread_mutex_t *__restrict __mutex,
|
|
const struct timespec *__restrict __abstime)
|
|
__attribute__ ((__nonnull__ (1, 2, 3)));
|
|
|
|
|
|
|
|
|
|
extern int pthread_condattr_init (pthread_condattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_condattr_getpshared (const pthread_condattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
|
|
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_condattr_getclock (const pthread_condattr_t *
|
|
__restrict __attr,
|
|
__clockid_t *__restrict __clock_id)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
|
|
__clockid_t __clock_id)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
# 1038 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
|
|
const pthread_barrierattr_t *__restrict
|
|
__attr, unsigned int __count)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
|
|
__restrict __attr,
|
|
int *__restrict __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
|
|
int __pshared)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
# 1105 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_key_create (pthread_key_t *__key,
|
|
void (*__destr_function) (void *))
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int pthread_key_delete (pthread_key_t __key) throw ();
|
|
|
|
|
|
extern void *pthread_getspecific (pthread_key_t __key) throw ();
|
|
|
|
|
|
extern int pthread_setspecific (pthread_key_t __key,
|
|
const void *__pointer) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int pthread_getcpuclockid (pthread_t __thread_id,
|
|
__clockid_t *__clock_id)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
# 1139 "/usr/include/pthread.h" 3 4
|
|
extern int pthread_atfork (void (*__prepare) (void),
|
|
void (*__parent) (void),
|
|
void (*__child) (void)) throw ();
|
|
# 1153 "/usr/include/pthread.h" 3 4
|
|
}
|
|
# 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 2 3
|
|
# 47 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
typedef pthread_t __gthread_t;
|
|
typedef pthread_key_t __gthread_key_t;
|
|
typedef pthread_once_t __gthread_once_t;
|
|
typedef pthread_mutex_t __gthread_mutex_t;
|
|
typedef pthread_mutex_t __gthread_recursive_mutex_t;
|
|
typedef pthread_cond_t __gthread_cond_t;
|
|
typedef struct timespec __gthread_time_t;
|
|
# 101 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
|
|
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
|
|
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
|
|
|
|
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
|
|
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
|
|
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
|
|
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
|
|
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
|
|
|
|
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
|
|
|
|
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
|
|
|
|
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
|
|
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
|
|
|
|
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
|
|
|
|
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
|
|
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
|
|
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
|
|
|
|
static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
|
|
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
|
|
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
|
|
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
|
|
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
|
|
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
|
|
|
|
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
|
|
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
|
|
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
|
|
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
|
|
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
|
|
# 236 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
|
|
# 246 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
static inline int
|
|
__gthread_active_p (void)
|
|
{
|
|
static void *const __gthread_active_ptr
|
|
= __extension__ (void *) &__gthrw___pthread_key_create;
|
|
return __gthread_active_ptr != 0;
|
|
}
|
|
# 658 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
static inline int
|
|
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
|
|
void *__args)
|
|
{
|
|
return __gthrw_pthread_create (__threadid, __null, __func, __args);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_join (__gthread_t __threadid, void **__value_ptr)
|
|
{
|
|
return __gthrw_pthread_join (__threadid, __value_ptr);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_detach (__gthread_t __threadid)
|
|
{
|
|
return __gthrw_pthread_detach (__threadid);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
|
|
{
|
|
return __gthrw_pthread_equal (__t1, __t2);
|
|
}
|
|
|
|
static inline __gthread_t
|
|
__gthread_self (void)
|
|
{
|
|
return __gthrw_pthread_self ();
|
|
}
|
|
|
|
static inline int
|
|
__gthread_yield (void)
|
|
{
|
|
return __gthrw_sched_yield ();
|
|
}
|
|
|
|
static inline int
|
|
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
|
|
{
|
|
if (__gthread_active_p ())
|
|
return __gthrw_pthread_once (__once, __func);
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
static inline int
|
|
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
|
|
{
|
|
return __gthrw_pthread_key_create (__key, __dtor);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_key_delete (__gthread_key_t __key)
|
|
{
|
|
return __gthrw_pthread_key_delete (__key);
|
|
}
|
|
|
|
static inline void *
|
|
__gthread_getspecific (__gthread_key_t __key)
|
|
{
|
|
return __gthrw_pthread_getspecific (__key);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
|
|
{
|
|
return __gthrw_pthread_setspecific (__key, __ptr);
|
|
}
|
|
|
|
static inline void
|
|
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
|
|
{
|
|
if (__gthread_active_p ())
|
|
__gthrw_pthread_mutex_init (__mutex, __null);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
|
|
{
|
|
if (__gthread_active_p ())
|
|
return __gthrw_pthread_mutex_destroy (__mutex);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
|
|
{
|
|
if (__gthread_active_p ())
|
|
return __gthrw_pthread_mutex_lock (__mutex);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
|
|
{
|
|
if (__gthread_active_p ())
|
|
return __gthrw_pthread_mutex_trylock (__mutex);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
static inline int
|
|
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
|
|
const __gthread_time_t *__abs_timeout)
|
|
{
|
|
if (__gthread_active_p ())
|
|
return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
static inline int
|
|
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
|
|
{
|
|
if (__gthread_active_p ())
|
|
return __gthrw_pthread_mutex_unlock (__mutex);
|
|
else
|
|
return 0;
|
|
}
|
|
# 807 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
static inline int
|
|
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
|
|
{
|
|
return __gthread_mutex_lock (__mutex);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
|
|
{
|
|
return __gthread_mutex_trylock (__mutex);
|
|
}
|
|
|
|
|
|
static inline int
|
|
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
|
|
const __gthread_time_t *__abs_timeout)
|
|
{
|
|
return __gthread_mutex_timedlock (__mutex, __abs_timeout);
|
|
}
|
|
|
|
|
|
static inline int
|
|
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
|
|
{
|
|
return __gthread_mutex_unlock (__mutex);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
|
|
{
|
|
return __gthread_mutex_destroy (__mutex);
|
|
}
|
|
# 849 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
|
|
static inline int
|
|
__gthread_cond_broadcast (__gthread_cond_t *__cond)
|
|
{
|
|
return __gthrw_pthread_cond_broadcast (__cond);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_cond_signal (__gthread_cond_t *__cond)
|
|
{
|
|
return __gthrw_pthread_cond_signal (__cond);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
|
|
{
|
|
return __gthrw_pthread_cond_wait (__cond, __mutex);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
|
|
const __gthread_time_t *__abs_timeout)
|
|
{
|
|
return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
|
|
__gthread_recursive_mutex_t *__mutex)
|
|
{
|
|
return __gthread_cond_wait (__cond, __mutex);
|
|
}
|
|
|
|
static inline int
|
|
__gthread_cond_destroy (__gthread_cond_t* __cond)
|
|
{
|
|
return __gthrw_pthread_cond_destroy (__cond);
|
|
}
|
|
# 149 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 2 3
|
|
|
|
|
|
#pragma GCC visibility pop
|
|
# 36 "/usr/include/c++/4.8.2/ext/atomicity.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/atomic_word.h" 1 3
|
|
# 32 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/atomic_word.h" 3
|
|
typedef int _Atomic_word;
|
|
# 37 "/usr/include/c++/4.8.2/ext/atomicity.h" 2 3
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline _Atomic_word
|
|
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
|
|
{ return __atomic_fetch_add(__mem, __val, 4); }
|
|
|
|
static inline void
|
|
__atomic_add(volatile _Atomic_word* __mem, int __val)
|
|
{ __atomic_fetch_add(__mem, __val, 4); }
|
|
# 64 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
|
|
static inline _Atomic_word
|
|
__exchange_and_add_single(_Atomic_word* __mem, int __val)
|
|
{
|
|
_Atomic_word __result = *__mem;
|
|
*__mem += __val;
|
|
return __result;
|
|
}
|
|
|
|
static inline void
|
|
__atomic_add_single(_Atomic_word* __mem, int __val)
|
|
{ *__mem += __val; }
|
|
|
|
static inline _Atomic_word
|
|
__attribute__ ((__unused__))
|
|
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
|
|
{
|
|
|
|
if (__gthread_active_p())
|
|
return __exchange_and_add(__mem, __val);
|
|
else
|
|
return __exchange_and_add_single(__mem, __val);
|
|
|
|
|
|
|
|
}
|
|
|
|
static inline void
|
|
__attribute__ ((__unused__))
|
|
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
|
|
{
|
|
|
|
if (__gthread_active_p())
|
|
__atomic_add(__mem, __val);
|
|
else
|
|
__atomic_add_single(__mem, __val);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
# 40 "/usr/include/c++/4.8.2/bits/ios_base.h" 2 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/locale_classes.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/string" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/string" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/string" 3
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/allocator.h" 1 3
|
|
# 46 "/usr/include/c++/4.8.2/bits/allocator.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/ext/new_allocator.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/new" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/new" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/new" 3
|
|
|
|
|
|
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
extern "C++" {
|
|
|
|
namespace std
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class bad_alloc : public exception
|
|
{
|
|
public:
|
|
bad_alloc() throw() { }
|
|
|
|
|
|
|
|
virtual ~bad_alloc() throw();
|
|
|
|
|
|
virtual const char* what() const throw();
|
|
};
|
|
|
|
struct nothrow_t { };
|
|
|
|
extern const nothrow_t nothrow;
|
|
|
|
|
|
|
|
typedef void (*new_handler)();
|
|
|
|
|
|
|
|
new_handler set_new_handler(new_handler) throw();
|
|
}
|
|
# 91 "/usr/include/c++/4.8.2/new" 3
|
|
void* operator new(std::size_t) throw(std::bad_alloc)
|
|
__attribute__((__externally_visible__));
|
|
void* operator new[](std::size_t) throw(std::bad_alloc)
|
|
__attribute__((__externally_visible__));
|
|
void operator delete(void*) throw()
|
|
__attribute__((__externally_visible__));
|
|
void operator delete[](void*) throw()
|
|
__attribute__((__externally_visible__));
|
|
void* operator new(std::size_t, const std::nothrow_t&) throw()
|
|
__attribute__((__externally_visible__));
|
|
void* operator new[](std::size_t, const std::nothrow_t&) throw()
|
|
__attribute__((__externally_visible__));
|
|
void operator delete(void*, const std::nothrow_t&) throw()
|
|
__attribute__((__externally_visible__));
|
|
void operator delete[](void*, const std::nothrow_t&) throw()
|
|
__attribute__((__externally_visible__));
|
|
|
|
|
|
inline void* operator new(std::size_t, void* __p) throw()
|
|
{ return __p; }
|
|
inline void* operator new[](std::size_t, void* __p) throw()
|
|
{ return __p; }
|
|
|
|
|
|
inline void operator delete (void*, void*) throw() { }
|
|
inline void operator delete[](void*, void*) throw() { }
|
|
|
|
}
|
|
|
|
#pragma GCC visibility pop
|
|
# 34 "/usr/include/c++/4.8.2/ext/new_allocator.h" 2 3
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
using std::size_t;
|
|
using std::ptrdiff_t;
|
|
# 57 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
|
|
template<typename _Tp>
|
|
class new_allocator
|
|
{
|
|
public:
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Tp* pointer;
|
|
typedef const _Tp* const_pointer;
|
|
typedef _Tp& reference;
|
|
typedef const _Tp& const_reference;
|
|
typedef _Tp value_type;
|
|
|
|
template<typename _Tp1>
|
|
struct rebind
|
|
{ typedef new_allocator<_Tp1> other; };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
new_allocator() throw() { }
|
|
|
|
new_allocator(const new_allocator&) throw() { }
|
|
|
|
template<typename _Tp1>
|
|
new_allocator(const new_allocator<_Tp1>&) throw() { }
|
|
|
|
~new_allocator() throw() { }
|
|
|
|
pointer
|
|
address(reference __x) const
|
|
{ return std::__addressof(__x); }
|
|
|
|
const_pointer
|
|
address(const_reference __x) const
|
|
{ return std::__addressof(__x); }
|
|
|
|
|
|
|
|
pointer
|
|
allocate(size_type __n, const void* = 0)
|
|
{
|
|
if (__n > this->max_size())
|
|
std::__throw_bad_alloc();
|
|
|
|
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
|
|
}
|
|
|
|
|
|
void
|
|
deallocate(pointer __p, size_type)
|
|
{ ::operator delete(__p); }
|
|
|
|
size_type
|
|
max_size() const throw()
|
|
{ return size_t(-1) / sizeof(_Tp); }
|
|
# 128 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
|
|
void
|
|
construct(pointer __p, const _Tp& __val)
|
|
{ ::new((void *)__p) _Tp(__val); }
|
|
|
|
void
|
|
destroy(pointer __p) { __p->~_Tp(); }
|
|
|
|
};
|
|
|
|
template<typename _Tp>
|
|
inline bool
|
|
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
|
|
{ return true; }
|
|
|
|
template<typename _Tp>
|
|
inline bool
|
|
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
|
|
{ return false; }
|
|
|
|
|
|
}
|
|
# 34 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 2 3
|
|
# 47 "/usr/include/c++/4.8.2/bits/allocator.h" 2 3
|
|
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<>
|
|
class allocator<void>
|
|
{
|
|
public:
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef void* pointer;
|
|
typedef const void* const_pointer;
|
|
typedef void value_type;
|
|
|
|
template<typename _Tp1>
|
|
struct rebind
|
|
{ typedef allocator<_Tp1> other; };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
# 91 "/usr/include/c++/4.8.2/bits/allocator.h" 3
|
|
template<typename _Tp>
|
|
class allocator: public __gnu_cxx::new_allocator<_Tp>
|
|
{
|
|
public:
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Tp* pointer;
|
|
typedef const _Tp* const_pointer;
|
|
typedef _Tp& reference;
|
|
typedef const _Tp& const_reference;
|
|
typedef _Tp value_type;
|
|
|
|
template<typename _Tp1>
|
|
struct rebind
|
|
{ typedef allocator<_Tp1> other; };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
allocator() throw() { }
|
|
|
|
allocator(const allocator& __a) throw()
|
|
: __gnu_cxx::new_allocator<_Tp>(__a) { }
|
|
|
|
template<typename _Tp1>
|
|
allocator(const allocator<_Tp1>&) throw() { }
|
|
|
|
~allocator() throw() { }
|
|
|
|
|
|
};
|
|
|
|
template<typename _T1, typename _T2>
|
|
inline bool
|
|
operator==(const allocator<_T1>&, const allocator<_T2>&)
|
|
{ return true; }
|
|
|
|
template<typename _Tp>
|
|
inline bool
|
|
operator==(const allocator<_Tp>&, const allocator<_Tp>&)
|
|
{ return true; }
|
|
|
|
template<typename _T1, typename _T2>
|
|
inline bool
|
|
operator!=(const allocator<_T1>&, const allocator<_T2>&)
|
|
{ return false; }
|
|
|
|
template<typename _Tp>
|
|
inline bool
|
|
operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
|
|
{ return false; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern template class allocator<char>;
|
|
extern template class allocator<wchar_t>;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Alloc, bool = __is_empty(_Alloc)>
|
|
struct __alloc_swap
|
|
{ static void _S_do_it(_Alloc&, _Alloc&) { } };
|
|
|
|
template<typename _Alloc>
|
|
struct __alloc_swap<_Alloc, false>
|
|
{
|
|
static void
|
|
_S_do_it(_Alloc& __one, _Alloc& __two)
|
|
{
|
|
|
|
if (__one != __two)
|
|
swap(__one, __two);
|
|
}
|
|
};
|
|
|
|
|
|
template<typename _Alloc, bool = __is_empty(_Alloc)>
|
|
struct __alloc_neq
|
|
{
|
|
static bool
|
|
_S_do_it(const _Alloc&, const _Alloc&)
|
|
{ return false; }
|
|
};
|
|
|
|
template<typename _Alloc>
|
|
struct __alloc_neq<_Alloc, false>
|
|
{
|
|
static bool
|
|
_S_do_it(const _Alloc& __one, const _Alloc& __two)
|
|
{ return __one != __two; }
|
|
};
|
|
# 218 "/usr/include/c++/4.8.2/bits/allocator.h" 3
|
|
|
|
}
|
|
# 42 "/usr/include/c++/4.8.2/string" 2 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 1 3
|
|
# 34 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 3
|
|
|
|
# 35 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 3
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
|
|
namespace __cxxabiv1
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class __forced_unwind
|
|
{
|
|
virtual ~__forced_unwind() throw();
|
|
|
|
|
|
virtual void __pure_dummy() = 0;
|
|
};
|
|
}
|
|
|
|
|
|
#pragma GCC visibility pop
|
|
# 37 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline void
|
|
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
|
|
const _CharT* __s, streamsize __n)
|
|
{
|
|
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
|
typedef typename __ostream_type::ios_base __ios_base;
|
|
|
|
const streamsize __put = __out.rdbuf()->sputn(__s, __n);
|
|
if (__put != __n)
|
|
__out.setstate(__ios_base::badbit);
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline void
|
|
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
|
|
{
|
|
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
|
typedef typename __ostream_type::ios_base __ios_base;
|
|
|
|
const _CharT __c = __out.fill();
|
|
for (; __n > 0; --__n)
|
|
{
|
|
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
|
|
if (_Traits::eq_int_type(__put, _Traits::eof()))
|
|
{
|
|
__out.setstate(__ios_base::badbit);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
|
|
const _CharT* __s, streamsize __n)
|
|
{
|
|
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
|
typedef typename __ostream_type::ios_base __ios_base;
|
|
|
|
typename __ostream_type::sentry __cerb(__out);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
const streamsize __w = __out.width();
|
|
if (__w > __n)
|
|
{
|
|
const bool __left = ((__out.flags()
|
|
& __ios_base::adjustfield)
|
|
== __ios_base::left);
|
|
if (!__left)
|
|
__ostream_fill(__out, __w - __n);
|
|
if (__out.good())
|
|
__ostream_write(__out, __s, __n);
|
|
if (__left && __out.good())
|
|
__ostream_fill(__out, __w - __n);
|
|
}
|
|
else
|
|
__ostream_write(__out, __s, __n);
|
|
__out.width(0);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__out._M_setstate(__ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ __out._M_setstate(__ios_base::badbit); }
|
|
}
|
|
return __out;
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
|
|
|
|
|
|
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
|
|
streamsize);
|
|
|
|
|
|
|
|
|
|
}
|
|
# 45 "/usr/include/c++/4.8.2/string" 2 3
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_function.h" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 100 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Arg, typename _Result>
|
|
struct unary_function
|
|
{
|
|
|
|
typedef _Arg argument_type;
|
|
|
|
|
|
typedef _Result result_type;
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Arg1, typename _Arg2, typename _Result>
|
|
struct binary_function
|
|
{
|
|
|
|
typedef _Arg1 first_argument_type;
|
|
|
|
|
|
typedef _Arg2 second_argument_type;
|
|
|
|
|
|
typedef _Result result_type;
|
|
};
|
|
# 139 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Tp>
|
|
struct plus : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x + __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct minus : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x - __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x * __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct divides : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x / __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct modulus : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x % __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct negate : public unary_function<_Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x) const
|
|
{ return -__x; }
|
|
};
|
|
# 203 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Tp>
|
|
struct equal_to : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x == __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x != __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct greater : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x > __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct less : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x < __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct greater_equal : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x >= __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct less_equal : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x <= __y; }
|
|
};
|
|
# 267 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Tp>
|
|
struct logical_and : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x && __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct logical_or : public binary_function<_Tp, _Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x || __y; }
|
|
};
|
|
|
|
|
|
template<typename _Tp>
|
|
struct logical_not : public unary_function<_Tp, bool>
|
|
{
|
|
bool
|
|
operator()(const _Tp& __x) const
|
|
{ return !__x; }
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x & __y; }
|
|
};
|
|
|
|
template<typename _Tp>
|
|
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x | __y; }
|
|
};
|
|
|
|
template<typename _Tp>
|
|
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
|
|
{
|
|
_Tp
|
|
operator()(const _Tp& __x, const _Tp& __y) const
|
|
{ return __x ^ __y; }
|
|
};
|
|
# 350 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Predicate>
|
|
class unary_negate
|
|
: public unary_function<typename _Predicate::argument_type, bool>
|
|
{
|
|
protected:
|
|
_Predicate _M_pred;
|
|
|
|
public:
|
|
explicit
|
|
unary_negate(const _Predicate& __x) : _M_pred(__x) { }
|
|
|
|
bool
|
|
operator()(const typename _Predicate::argument_type& __x) const
|
|
{ return !_M_pred(__x); }
|
|
};
|
|
|
|
|
|
template<typename _Predicate>
|
|
inline unary_negate<_Predicate>
|
|
not1(const _Predicate& __pred)
|
|
{ return unary_negate<_Predicate>(__pred); }
|
|
|
|
|
|
template<typename _Predicate>
|
|
class binary_negate
|
|
: public binary_function<typename _Predicate::first_argument_type,
|
|
typename _Predicate::second_argument_type, bool>
|
|
{
|
|
protected:
|
|
_Predicate _M_pred;
|
|
|
|
public:
|
|
explicit
|
|
binary_negate(const _Predicate& __x) : _M_pred(__x) { }
|
|
|
|
bool
|
|
operator()(const typename _Predicate::first_argument_type& __x,
|
|
const typename _Predicate::second_argument_type& __y) const
|
|
{ return !_M_pred(__x, __y); }
|
|
};
|
|
|
|
|
|
template<typename _Predicate>
|
|
inline binary_negate<_Predicate>
|
|
not2(const _Predicate& __pred)
|
|
{ return binary_negate<_Predicate>(__pred); }
|
|
# 421 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Arg, typename _Result>
|
|
class pointer_to_unary_function : public unary_function<_Arg, _Result>
|
|
{
|
|
protected:
|
|
_Result (*_M_ptr)(_Arg);
|
|
|
|
public:
|
|
pointer_to_unary_function() { }
|
|
|
|
explicit
|
|
pointer_to_unary_function(_Result (*__x)(_Arg))
|
|
: _M_ptr(__x) { }
|
|
|
|
_Result
|
|
operator()(_Arg __x) const
|
|
{ return _M_ptr(__x); }
|
|
};
|
|
|
|
|
|
template<typename _Arg, typename _Result>
|
|
inline pointer_to_unary_function<_Arg, _Result>
|
|
ptr_fun(_Result (*__x)(_Arg))
|
|
{ return pointer_to_unary_function<_Arg, _Result>(__x); }
|
|
|
|
|
|
template<typename _Arg1, typename _Arg2, typename _Result>
|
|
class pointer_to_binary_function
|
|
: public binary_function<_Arg1, _Arg2, _Result>
|
|
{
|
|
protected:
|
|
_Result (*_M_ptr)(_Arg1, _Arg2);
|
|
|
|
public:
|
|
pointer_to_binary_function() { }
|
|
|
|
explicit
|
|
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
|
|
: _M_ptr(__x) { }
|
|
|
|
_Result
|
|
operator()(_Arg1 __x, _Arg2 __y) const
|
|
{ return _M_ptr(__x, __y); }
|
|
};
|
|
|
|
|
|
template<typename _Arg1, typename _Arg2, typename _Result>
|
|
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
|
|
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
|
|
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
|
|
|
|
|
|
template<typename _Tp>
|
|
struct _Identity
|
|
: public unary_function<_Tp,_Tp>
|
|
{
|
|
_Tp&
|
|
operator()(_Tp& __x) const
|
|
{ return __x; }
|
|
|
|
const _Tp&
|
|
operator()(const _Tp& __x) const
|
|
{ return __x; }
|
|
};
|
|
|
|
template<typename _Pair>
|
|
struct _Select1st
|
|
: public unary_function<_Pair, typename _Pair::first_type>
|
|
{
|
|
typename _Pair::first_type&
|
|
operator()(_Pair& __x) const
|
|
{ return __x.first; }
|
|
|
|
const typename _Pair::first_type&
|
|
operator()(const _Pair& __x) const
|
|
{ return __x.first; }
|
|
# 508 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
};
|
|
|
|
template<typename _Pair>
|
|
struct _Select2nd
|
|
: public unary_function<_Pair, typename _Pair::second_type>
|
|
{
|
|
typename _Pair::second_type&
|
|
operator()(_Pair& __x) const
|
|
{ return __x.second; }
|
|
|
|
const typename _Pair::second_type&
|
|
operator()(const _Pair& __x) const
|
|
{ return __x.second; }
|
|
};
|
|
# 541 "/usr/include/c++/4.8.2/bits/stl_function.h" 3
|
|
template<typename _Ret, typename _Tp>
|
|
class mem_fun_t : public unary_function<_Tp*, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
mem_fun_t(_Ret (_Tp::*__pf)())
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(_Tp* __p) const
|
|
{ return (__p->*_M_f)(); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)();
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
const_mem_fun_t(_Ret (_Tp::*__pf)() const)
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(const _Tp* __p) const
|
|
{ return (__p->*_M_f)(); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)() const;
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
class mem_fun_ref_t : public unary_function<_Tp, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
mem_fun_ref_t(_Ret (_Tp::*__pf)())
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(_Tp& __r) const
|
|
{ return (__r.*_M_f)(); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)();
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(const _Tp& __r) const
|
|
{ return (__r.*_M_f)(); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)() const;
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(_Tp* __p, _Arg __x) const
|
|
{ return (__p->*_M_f)(__x); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)(_Arg);
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(const _Tp* __p, _Arg __x) const
|
|
{ return (__p->*_M_f)(__x); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)(_Arg) const;
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(_Tp& __r, _Arg __x) const
|
|
{ return (__r.*_M_f)(__x); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)(_Arg);
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
|
|
{
|
|
public:
|
|
explicit
|
|
const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
|
|
: _M_f(__pf) { }
|
|
|
|
_Ret
|
|
operator()(const _Tp& __r, _Arg __x) const
|
|
{ return (__r.*_M_f)(__x); }
|
|
|
|
private:
|
|
_Ret (_Tp::*_M_f)(_Arg) const;
|
|
};
|
|
|
|
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
inline mem_fun_t<_Ret, _Tp>
|
|
mem_fun(_Ret (_Tp::*__f)())
|
|
{ return mem_fun_t<_Ret, _Tp>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
inline const_mem_fun_t<_Ret, _Tp>
|
|
mem_fun(_Ret (_Tp::*__f)() const)
|
|
{ return const_mem_fun_t<_Ret, _Tp>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
inline mem_fun_ref_t<_Ret, _Tp>
|
|
mem_fun_ref(_Ret (_Tp::*__f)())
|
|
{ return mem_fun_ref_t<_Ret, _Tp>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp>
|
|
inline const_mem_fun_ref_t<_Ret, _Tp>
|
|
mem_fun_ref(_Ret (_Tp::*__f)() const)
|
|
{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
inline mem_fun1_t<_Ret, _Tp, _Arg>
|
|
mem_fun(_Ret (_Tp::*__f)(_Arg))
|
|
{ return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
inline const_mem_fun1_t<_Ret, _Tp, _Arg>
|
|
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
|
|
{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
|
|
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
|
|
{ return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
|
|
|
|
template<typename _Ret, typename _Tp, typename _Arg>
|
|
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
|
|
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
|
|
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/backward/binders.h" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/backward/binders.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 103 "/usr/include/c++/4.8.2/backward/binders.h" 3
|
|
template<typename _Operation>
|
|
class binder1st
|
|
: public unary_function<typename _Operation::second_argument_type,
|
|
typename _Operation::result_type>
|
|
{
|
|
protected:
|
|
_Operation op;
|
|
typename _Operation::first_argument_type value;
|
|
|
|
public:
|
|
binder1st(const _Operation& __x,
|
|
const typename _Operation::first_argument_type& __y)
|
|
: op(__x), value(__y) { }
|
|
|
|
typename _Operation::result_type
|
|
operator()(const typename _Operation::second_argument_type& __x) const
|
|
{ return op(value, __x); }
|
|
|
|
|
|
|
|
typename _Operation::result_type
|
|
operator()(typename _Operation::second_argument_type& __x) const
|
|
{ return op(value, __x); }
|
|
} ;
|
|
|
|
|
|
template<typename _Operation, typename _Tp>
|
|
inline binder1st<_Operation>
|
|
bind1st(const _Operation& __fn, const _Tp& __x)
|
|
{
|
|
typedef typename _Operation::first_argument_type _Arg1_type;
|
|
return binder1st<_Operation>(__fn, _Arg1_type(__x));
|
|
}
|
|
|
|
|
|
template<typename _Operation>
|
|
class binder2nd
|
|
: public unary_function<typename _Operation::first_argument_type,
|
|
typename _Operation::result_type>
|
|
{
|
|
protected:
|
|
_Operation op;
|
|
typename _Operation::second_argument_type value;
|
|
|
|
public:
|
|
binder2nd(const _Operation& __x,
|
|
const typename _Operation::second_argument_type& __y)
|
|
: op(__x), value(__y) { }
|
|
|
|
typename _Operation::result_type
|
|
operator()(const typename _Operation::first_argument_type& __x) const
|
|
{ return op(__x, value); }
|
|
|
|
|
|
|
|
typename _Operation::result_type
|
|
operator()(typename _Operation::first_argument_type& __x) const
|
|
{ return op(__x, value); }
|
|
} ;
|
|
|
|
|
|
template<typename _Operation, typename _Tp>
|
|
inline binder2nd<_Operation>
|
|
bind2nd(const _Operation& __fn, const _Tp& __x)
|
|
{
|
|
typedef typename _Operation::second_argument_type _Arg2_type;
|
|
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
|
|
}
|
|
|
|
|
|
|
|
}
|
|
# 732 "/usr/include/c++/4.8.2/bits/stl_function.h" 2 3
|
|
# 49 "/usr/include/c++/4.8.2/string" 2 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/range_access.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/range_access.h" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/range_access.h" 3
|
|
# 52 "/usr/include/c++/4.8.2/string" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/basic_string.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 111 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
class basic_string
|
|
{
|
|
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
|
|
|
|
|
|
public:
|
|
typedef _Traits traits_type;
|
|
typedef typename _Traits::char_type value_type;
|
|
typedef _Alloc allocator_type;
|
|
typedef typename _CharT_alloc_type::size_type size_type;
|
|
typedef typename _CharT_alloc_type::difference_type difference_type;
|
|
typedef typename _CharT_alloc_type::reference reference;
|
|
typedef typename _CharT_alloc_type::const_reference const_reference;
|
|
typedef typename _CharT_alloc_type::pointer pointer;
|
|
typedef typename _CharT_alloc_type::const_pointer const_pointer;
|
|
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
|
|
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
|
|
const_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
|
|
private:
|
|
# 148 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
struct _Rep_base
|
|
{
|
|
size_type _M_length;
|
|
size_type _M_capacity;
|
|
_Atomic_word _M_refcount;
|
|
};
|
|
|
|
struct _Rep : _Rep_base
|
|
{
|
|
|
|
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
|
|
# 173 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
static const size_type _S_max_size;
|
|
static const _CharT _S_terminal;
|
|
|
|
|
|
|
|
static size_type _S_empty_rep_storage[];
|
|
|
|
static _Rep&
|
|
_S_empty_rep()
|
|
{
|
|
|
|
|
|
|
|
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
|
|
return *reinterpret_cast<_Rep*>(__p);
|
|
}
|
|
|
|
bool
|
|
_M_is_leaked() const
|
|
{ return this->_M_refcount < 0; }
|
|
|
|
bool
|
|
_M_is_shared() const
|
|
{ return this->_M_refcount > 0; }
|
|
|
|
void
|
|
_M_set_leaked()
|
|
{ this->_M_refcount = -1; }
|
|
|
|
void
|
|
_M_set_sharable()
|
|
{ this->_M_refcount = 0; }
|
|
|
|
void
|
|
_M_set_length_and_sharable(size_type __n)
|
|
{
|
|
|
|
if (__builtin_expect(this != &_S_empty_rep(), false))
|
|
|
|
{
|
|
this->_M_set_sharable();
|
|
this->_M_length = __n;
|
|
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
|
|
|
|
|
|
}
|
|
}
|
|
|
|
_CharT*
|
|
_M_refdata() throw()
|
|
{ return reinterpret_cast<_CharT*>(this + 1); }
|
|
|
|
_CharT*
|
|
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
|
|
{
|
|
return (!_M_is_leaked() && __alloc1 == __alloc2)
|
|
? _M_refcopy() : _M_clone(__alloc1);
|
|
}
|
|
|
|
|
|
static _Rep*
|
|
_S_create(size_type, size_type, const _Alloc&);
|
|
|
|
void
|
|
_M_dispose(const _Alloc& __a)
|
|
{
|
|
|
|
if (__builtin_expect(this != &_S_empty_rep(), false))
|
|
|
|
{
|
|
|
|
;
|
|
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
|
|
-1) <= 0)
|
|
{
|
|
;
|
|
_M_destroy(__a);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
_M_destroy(const _Alloc&) throw();
|
|
|
|
_CharT*
|
|
_M_refcopy() throw()
|
|
{
|
|
|
|
if (__builtin_expect(this != &_S_empty_rep(), false))
|
|
|
|
__gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
|
|
return _M_refdata();
|
|
}
|
|
|
|
_CharT*
|
|
_M_clone(const _Alloc&, size_type __res = 0);
|
|
};
|
|
|
|
|
|
struct _Alloc_hider : _Alloc
|
|
{
|
|
_Alloc_hider(_CharT* __dat, const _Alloc& __a)
|
|
: _Alloc(__a), _M_p(__dat) { }
|
|
|
|
_CharT* _M_p;
|
|
};
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
static const size_type npos = static_cast<size_type>(-1);
|
|
|
|
private:
|
|
|
|
mutable _Alloc_hider _M_dataplus;
|
|
|
|
_CharT*
|
|
_M_data() const
|
|
{ return _M_dataplus._M_p; }
|
|
|
|
_CharT*
|
|
_M_data(_CharT* __p)
|
|
{ return (_M_dataplus._M_p = __p); }
|
|
|
|
_Rep*
|
|
_M_rep() const
|
|
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
|
|
|
|
|
|
|
|
iterator
|
|
_M_ibegin() const
|
|
{ return iterator(_M_data()); }
|
|
|
|
iterator
|
|
_M_iend() const
|
|
{ return iterator(_M_data() + this->size()); }
|
|
|
|
void
|
|
_M_leak()
|
|
{
|
|
if (!_M_rep()->_M_is_leaked())
|
|
_M_leak_hard();
|
|
}
|
|
|
|
size_type
|
|
_M_check(size_type __pos, const char* __s) const
|
|
{
|
|
if (__pos > this->size())
|
|
__throw_out_of_range((__s));
|
|
return __pos;
|
|
}
|
|
|
|
void
|
|
_M_check_length(size_type __n1, size_type __n2, const char* __s) const
|
|
{
|
|
if (this->max_size() - (this->size() - __n1) < __n2)
|
|
__throw_length_error((__s));
|
|
}
|
|
|
|
|
|
size_type
|
|
_M_limit(size_type __pos, size_type __off) const
|
|
{
|
|
const bool __testoff = __off < this->size() - __pos;
|
|
return __testoff ? __off : this->size() - __pos;
|
|
}
|
|
|
|
|
|
bool
|
|
_M_disjunct(const _CharT* __s) const
|
|
{
|
|
return (less<const _CharT*>()(__s, _M_data())
|
|
|| less<const _CharT*>()(_M_data() + this->size(), __s));
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
_M_copy(_CharT* __d, const _CharT* __s, size_type __n)
|
|
{
|
|
if (__n == 1)
|
|
traits_type::assign(*__d, *__s);
|
|
else
|
|
traits_type::copy(__d, __s, __n);
|
|
}
|
|
|
|
static void
|
|
_M_move(_CharT* __d, const _CharT* __s, size_type __n)
|
|
{
|
|
if (__n == 1)
|
|
traits_type::assign(*__d, *__s);
|
|
else
|
|
traits_type::move(__d, __s, __n);
|
|
}
|
|
|
|
static void
|
|
_M_assign(_CharT* __d, size_type __n, _CharT __c)
|
|
{
|
|
if (__n == 1)
|
|
traits_type::assign(*__d, __c);
|
|
else
|
|
traits_type::assign(__d, __n, __c);
|
|
}
|
|
|
|
|
|
|
|
template<class _Iterator>
|
|
static void
|
|
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
|
|
{
|
|
for (; __k1 != __k2; ++__k1, ++__p)
|
|
traits_type::assign(*__p, *__k1);
|
|
}
|
|
|
|
static void
|
|
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
|
|
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
|
|
|
|
static void
|
|
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
|
|
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
|
|
|
|
static void
|
|
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
|
|
{ _M_copy(__p, __k1, __k2 - __k1); }
|
|
|
|
static void
|
|
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
|
|
{ _M_copy(__p, __k1, __k2 - __k1); }
|
|
|
|
static int
|
|
_S_compare(size_type __n1, size_type __n2)
|
|
{
|
|
const difference_type __d = difference_type(__n1 - __n2);
|
|
|
|
if (__d > __gnu_cxx::__numeric_traits<int>::__max)
|
|
return __gnu_cxx::__numeric_traits<int>::__max;
|
|
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
|
|
return __gnu_cxx::__numeric_traits<int>::__min;
|
|
else
|
|
return int(__d);
|
|
}
|
|
|
|
void
|
|
_M_mutate(size_type __pos, size_type __len1, size_type __len2);
|
|
|
|
void
|
|
_M_leak_hard();
|
|
|
|
static _Rep&
|
|
_S_empty_rep()
|
|
{ return _Rep::_S_empty_rep(); }
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string()
|
|
|
|
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
basic_string(const _Alloc& __a);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string(const basic_string& __str);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string(const basic_string& __str, size_type __pos,
|
|
size_type __n = npos);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string(const basic_string& __str, size_type __pos,
|
|
size_type __n, const _Alloc& __a);
|
|
# 483 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string(const _CharT* __s, size_type __n,
|
|
const _Alloc& __a = _Alloc());
|
|
|
|
|
|
|
|
|
|
|
|
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
|
|
# 531 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<class _InputIterator>
|
|
basic_string(_InputIterator __beg, _InputIterator __end,
|
|
const _Alloc& __a = _Alloc());
|
|
|
|
|
|
|
|
|
|
~basic_string()
|
|
{ _M_rep()->_M_dispose(this->get_allocator()); }
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
operator=(const basic_string& __str)
|
|
{ return this->assign(__str); }
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
operator=(const _CharT* __s)
|
|
{ return this->assign(__s); }
|
|
# 564 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
operator=(_CharT __c)
|
|
{
|
|
this->assign(1, __c);
|
|
return *this;
|
|
}
|
|
# 604 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
iterator
|
|
begin()
|
|
{
|
|
_M_leak();
|
|
return iterator(_M_data());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return const_iterator(_M_data()); }
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end()
|
|
{
|
|
_M_leak();
|
|
return iterator(_M_data() + this->size());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return const_iterator(_M_data() + this->size()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return reverse_iterator(this->end()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return const_reverse_iterator(this->end()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return reverse_iterator(this->begin()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return const_reverse_iterator(this->begin()); }
|
|
# 710 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
public:
|
|
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return _M_rep()->_M_length; }
|
|
|
|
|
|
|
|
size_type
|
|
length() const
|
|
{ return _M_rep()->_M_length; }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _Rep::_S_max_size; }
|
|
# 739 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
void
|
|
resize(size_type __n, _CharT __c);
|
|
# 752 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
void
|
|
resize(size_type __n)
|
|
{ this->resize(__n, _CharT()); }
|
|
# 775 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
capacity() const
|
|
{ return _M_rep()->_M_capacity; }
|
|
# 796 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
void
|
|
reserve(size_type __res_arg = 0);
|
|
|
|
|
|
|
|
|
|
void
|
|
clear()
|
|
{ _M_mutate(0, this->size(), 0); }
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
empty() const
|
|
{ return this->size() == 0; }
|
|
# 825 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
const_reference
|
|
operator[] (size_type __pos) const
|
|
{
|
|
;
|
|
return _M_data()[__pos];
|
|
}
|
|
# 842 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
reference
|
|
operator[](size_type __pos)
|
|
{
|
|
|
|
;
|
|
|
|
;
|
|
_M_leak();
|
|
return _M_data()[__pos];
|
|
}
|
|
# 863 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
const_reference
|
|
at(size_type __n) const
|
|
{
|
|
if (__n >= this->size())
|
|
__throw_out_of_range(("basic_string::at"));
|
|
return _M_data()[__n];
|
|
}
|
|
# 882 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
reference
|
|
at(size_type __n)
|
|
{
|
|
if (__n >= size())
|
|
__throw_out_of_range(("basic_string::at"));
|
|
_M_leak();
|
|
return _M_data()[__n];
|
|
}
|
|
# 931 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
operator+=(const basic_string& __str)
|
|
{ return this->append(__str); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
operator+=(const _CharT* __s)
|
|
{ return this->append(__s); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
operator+=(_CharT __c)
|
|
{
|
|
this->push_back(__c);
|
|
return *this;
|
|
}
|
|
# 972 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
append(const basic_string& __str);
|
|
# 988 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
append(const basic_string& __str, size_type __pos, size_type __n);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
append(const _CharT* __s, size_type __n);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
append(const _CharT* __s)
|
|
{
|
|
;
|
|
return this->append(__s, traits_type::length(__s));
|
|
}
|
|
# 1020 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
append(size_type __n, _CharT __c);
|
|
# 1042 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<class _InputIterator>
|
|
basic_string&
|
|
append(_InputIterator __first, _InputIterator __last)
|
|
{ return this->replace(_M_iend(), _M_iend(), __first, __last); }
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
push_back(_CharT __c)
|
|
{
|
|
const size_type __len = 1 + this->size();
|
|
if (__len > this->capacity() || _M_rep()->_M_is_shared())
|
|
this->reserve(__len);
|
|
traits_type::assign(_M_data()[this->size()], __c);
|
|
_M_rep()->_M_set_length_and_sharable(__len);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_string&
|
|
assign(const basic_string& __str);
|
|
# 1099 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
assign(const basic_string& __str, size_type __pos, size_type __n)
|
|
{ return this->assign(__str._M_data()
|
|
+ __str._M_check(__pos, "basic_string::assign"),
|
|
__str._M_limit(__pos, __n)); }
|
|
# 1115 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
assign(const _CharT* __s, size_type __n);
|
|
# 1127 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
assign(const _CharT* __s)
|
|
{
|
|
;
|
|
return this->assign(__s, traits_type::length(__s));
|
|
}
|
|
# 1143 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
assign(size_type __n, _CharT __c)
|
|
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); }
|
|
# 1155 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<class _InputIterator>
|
|
basic_string&
|
|
assign(_InputIterator __first, _InputIterator __last)
|
|
{ return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
|
|
# 1184 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
void
|
|
insert(iterator __p, size_type __n, _CharT __c)
|
|
{ this->replace(__p, __p, __n, __c); }
|
|
# 1200 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<class _InputIterator>
|
|
void
|
|
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
|
|
{ this->replace(__p, __p, __beg, __end); }
|
|
# 1232 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
insert(size_type __pos1, const basic_string& __str)
|
|
{ return this->insert(__pos1, __str, size_type(0), __str.size()); }
|
|
# 1254 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
insert(size_type __pos1, const basic_string& __str,
|
|
size_type __pos2, size_type __n)
|
|
{ return this->insert(__pos1, __str._M_data()
|
|
+ __str._M_check(__pos2, "basic_string::insert"),
|
|
__str._M_limit(__pos2, __n)); }
|
|
# 1277 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
insert(size_type __pos, const _CharT* __s, size_type __n);
|
|
# 1295 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
insert(size_type __pos, const _CharT* __s)
|
|
{
|
|
;
|
|
return this->insert(__pos, __s, traits_type::length(__s));
|
|
}
|
|
# 1318 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
insert(size_type __pos, size_type __n, _CharT __c)
|
|
{ return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
|
|
size_type(0), __n, __c); }
|
|
# 1336 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
iterator
|
|
insert(iterator __p, _CharT __c)
|
|
{
|
|
;
|
|
const size_type __pos = __p - _M_ibegin();
|
|
_M_replace_aux(__pos, size_type(0), size_type(1), __c);
|
|
_M_rep()->_M_set_leaked();
|
|
return iterator(_M_data() + __pos);
|
|
}
|
|
# 1361 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
erase(size_type __pos = 0, size_type __n = npos)
|
|
{
|
|
_M_mutate(_M_check(__pos, "basic_string::erase"),
|
|
_M_limit(__pos, __n), size_type(0));
|
|
return *this;
|
|
}
|
|
# 1377 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
iterator
|
|
erase(iterator __position)
|
|
{
|
|
|
|
;
|
|
const size_type __pos = __position - _M_ibegin();
|
|
_M_mutate(__pos, size_type(1), size_type(0));
|
|
_M_rep()->_M_set_leaked();
|
|
return iterator(_M_data() + __pos);
|
|
}
|
|
# 1397 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
iterator
|
|
erase(iterator __first, iterator __last);
|
|
# 1428 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(size_type __pos, size_type __n, const basic_string& __str)
|
|
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); }
|
|
# 1450 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(size_type __pos1, size_type __n1, const basic_string& __str,
|
|
size_type __pos2, size_type __n2)
|
|
{ return this->replace(__pos1, __n1, __str._M_data()
|
|
+ __str._M_check(__pos2, "basic_string::replace"),
|
|
__str._M_limit(__pos2, __n2)); }
|
|
# 1475 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(size_type __pos, size_type __n1, const _CharT* __s,
|
|
size_type __n2);
|
|
# 1495 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(size_type __pos, size_type __n1, const _CharT* __s)
|
|
{
|
|
;
|
|
return this->replace(__pos, __n1, __s, traits_type::length(__s));
|
|
}
|
|
# 1519 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
|
|
{ return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
|
|
_M_limit(__pos, __n1), __n2, __c); }
|
|
# 1537 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2, const basic_string& __str)
|
|
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
|
|
# 1556 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
|
|
{
|
|
|
|
;
|
|
return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
|
|
}
|
|
# 1577 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2, const _CharT* __s)
|
|
{
|
|
;
|
|
return this->replace(__i1, __i2, __s, traits_type::length(__s));
|
|
}
|
|
# 1598 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
|
|
{
|
|
|
|
;
|
|
return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
|
|
}
|
|
# 1621 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<class _InputIterator>
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2,
|
|
_InputIterator __k1, _InputIterator __k2)
|
|
{
|
|
|
|
;
|
|
;
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
|
|
}
|
|
|
|
|
|
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
|
|
{
|
|
|
|
;
|
|
;
|
|
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
|
|
__k1, __k2 - __k1);
|
|
}
|
|
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2,
|
|
const _CharT* __k1, const _CharT* __k2)
|
|
{
|
|
|
|
;
|
|
;
|
|
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
|
|
__k1, __k2 - __k1);
|
|
}
|
|
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
|
|
{
|
|
|
|
;
|
|
;
|
|
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
|
|
__k1.base(), __k2 - __k1);
|
|
}
|
|
|
|
basic_string&
|
|
replace(iterator __i1, iterator __i2,
|
|
const_iterator __k1, const_iterator __k2)
|
|
{
|
|
|
|
;
|
|
;
|
|
return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
|
|
__k1.base(), __k2 - __k1);
|
|
}
|
|
# 1697 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
private:
|
|
template<class _Integer>
|
|
basic_string&
|
|
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
|
|
_Integer __val, __true_type)
|
|
{ return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
|
|
|
|
template<class _InputIterator>
|
|
basic_string&
|
|
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
|
|
_InputIterator __k2, __false_type);
|
|
|
|
basic_string&
|
|
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
|
|
_CharT __c);
|
|
|
|
basic_string&
|
|
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
|
|
size_type __n2);
|
|
|
|
|
|
|
|
template<class _InIterator>
|
|
static _CharT*
|
|
_S_construct_aux(_InIterator __beg, _InIterator __end,
|
|
const _Alloc& __a, __false_type)
|
|
{
|
|
typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
|
|
return _S_construct(__beg, __end, __a, _Tag());
|
|
}
|
|
|
|
|
|
|
|
template<class _Integer>
|
|
static _CharT*
|
|
_S_construct_aux(_Integer __beg, _Integer __end,
|
|
const _Alloc& __a, __true_type)
|
|
{ return _S_construct_aux_2(static_cast<size_type>(__beg),
|
|
__end, __a); }
|
|
|
|
static _CharT*
|
|
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
|
|
{ return _S_construct(__req, __c, __a); }
|
|
|
|
template<class _InIterator>
|
|
static _CharT*
|
|
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
|
|
{
|
|
typedef typename std::__is_integer<_InIterator>::__type _Integral;
|
|
return _S_construct_aux(__beg, __end, __a, _Integral());
|
|
}
|
|
|
|
|
|
template<class _InIterator>
|
|
static _CharT*
|
|
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
|
|
input_iterator_tag);
|
|
|
|
|
|
|
|
template<class _FwdIterator>
|
|
static _CharT*
|
|
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
|
|
forward_iterator_tag);
|
|
|
|
static _CharT*
|
|
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
|
|
|
|
public:
|
|
# 1779 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
|
|
# 1789 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
void
|
|
swap(basic_string& __s);
|
|
# 1799 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
const _CharT*
|
|
c_str() const
|
|
{ return _M_data(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const _CharT*
|
|
data() const
|
|
{ return _M_data(); }
|
|
|
|
|
|
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return _M_dataplus; }
|
|
# 1832 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find(const _CharT* __s, size_type __pos, size_type __n) const;
|
|
# 1845 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find(const basic_string& __str, size_type __pos = 0) const
|
|
|
|
{ return this->find(__str.data(), __pos, __str.size()); }
|
|
# 1860 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find(const _CharT* __s, size_type __pos = 0) const
|
|
{
|
|
;
|
|
return this->find(__s, __pos, traits_type::length(__s));
|
|
}
|
|
# 1877 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find(_CharT __c, size_type __pos = 0) const ;
|
|
# 1890 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
rfind(const basic_string& __str, size_type __pos = npos) const
|
|
|
|
{ return this->rfind(__str.data(), __pos, __str.size()); }
|
|
# 1907 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
|
|
# 1920 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
rfind(const _CharT* __s, size_type __pos = npos) const
|
|
{
|
|
;
|
|
return this->rfind(__s, __pos, traits_type::length(__s));
|
|
}
|
|
# 1937 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
rfind(_CharT __c, size_type __pos = npos) const ;
|
|
# 1951 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_of(const basic_string& __str, size_type __pos = 0) const
|
|
|
|
{ return this->find_first_of(__str.data(), __pos, __str.size()); }
|
|
# 1968 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
|
|
# 1981 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_of(const _CharT* __s, size_type __pos = 0) const
|
|
{
|
|
;
|
|
return this->find_first_of(__s, __pos, traits_type::length(__s));
|
|
}
|
|
# 2000 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_of(_CharT __c, size_type __pos = 0) const
|
|
{ return this->find(__c, __pos); }
|
|
# 2015 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_of(const basic_string& __str, size_type __pos = npos) const
|
|
|
|
{ return this->find_last_of(__str.data(), __pos, __str.size()); }
|
|
# 2032 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
|
|
# 2045 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_of(const _CharT* __s, size_type __pos = npos) const
|
|
{
|
|
;
|
|
return this->find_last_of(__s, __pos, traits_type::length(__s));
|
|
}
|
|
# 2064 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_of(_CharT __c, size_type __pos = npos) const
|
|
{ return this->rfind(__c, __pos); }
|
|
# 2078 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
|
|
|
|
{ return this->find_first_not_of(__str.data(), __pos, __str.size()); }
|
|
# 2095 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_not_of(const _CharT* __s, size_type __pos,
|
|
size_type __n) const;
|
|
# 2109 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
|
|
{
|
|
;
|
|
return this->find_first_not_of(__s, __pos, traits_type::length(__s));
|
|
}
|
|
# 2126 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_first_not_of(_CharT __c, size_type __pos = 0) const
|
|
;
|
|
# 2141 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_not_of(const basic_string& __str, size_type __pos = npos) const
|
|
|
|
{ return this->find_last_not_of(__str.data(), __pos, __str.size()); }
|
|
# 2158 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_not_of(const _CharT* __s, size_type __pos,
|
|
size_type __n) const;
|
|
# 2172 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
|
|
{
|
|
;
|
|
return this->find_last_not_of(__s, __pos, traits_type::length(__s));
|
|
}
|
|
# 2189 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
size_type
|
|
find_last_not_of(_CharT __c, size_type __pos = npos) const
|
|
;
|
|
# 2205 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
basic_string
|
|
substr(size_type __pos = 0, size_type __n = npos) const
|
|
{ return basic_string(*this,
|
|
_M_check(__pos, "basic_string::substr"), __n); }
|
|
# 2224 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
int
|
|
compare(const basic_string& __str) const
|
|
{
|
|
const size_type __size = this->size();
|
|
const size_type __osize = __str.size();
|
|
const size_type __len = std::min(__size, __osize);
|
|
|
|
int __r = traits_type::compare(_M_data(), __str.data(), __len);
|
|
if (!__r)
|
|
__r = _S_compare(__size, __osize);
|
|
return __r;
|
|
}
|
|
# 2256 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
int
|
|
compare(size_type __pos, size_type __n, const basic_string& __str) const;
|
|
# 2282 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
int
|
|
compare(size_type __pos1, size_type __n1, const basic_string& __str,
|
|
size_type __pos2, size_type __n2) const;
|
|
# 2300 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
int
|
|
compare(const _CharT* __s) const;
|
|
# 2324 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
int
|
|
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
|
|
# 2351 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
int
|
|
compare(size_type __pos, size_type __n1, const _CharT* __s,
|
|
size_type __n2) const;
|
|
};
|
|
# 2363 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>
|
|
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{
|
|
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
|
|
__str.append(__rhs);
|
|
return __str;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT,_Traits,_Alloc>
|
|
operator+(const _CharT* __lhs,
|
|
const basic_string<_CharT,_Traits,_Alloc>& __rhs);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT,_Traits,_Alloc>
|
|
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline basic_string<_CharT, _Traits, _Alloc>
|
|
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{
|
|
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
|
|
__str.append(__rhs);
|
|
return __str;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline basic_string<_CharT, _Traits, _Alloc>
|
|
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
|
|
{
|
|
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
|
typedef typename __string_type::size_type __size_type;
|
|
__string_type __str(__lhs);
|
|
__str.append(__size_type(1), __rhs);
|
|
return __str;
|
|
}
|
|
# 2484 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __lhs.compare(__rhs) == 0; }
|
|
|
|
template<typename _CharT>
|
|
inline
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
|
|
operator==(const basic_string<_CharT>& __lhs,
|
|
const basic_string<_CharT>& __rhs)
|
|
{ return (__lhs.size() == __rhs.size()
|
|
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
|
|
__lhs.size())); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator==(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __rhs.compare(__lhs) == 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{ return __lhs.compare(__rhs) == 0; }
|
|
# 2530 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return !(__lhs == __rhs); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator!=(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return !(__lhs == __rhs); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{ return !(__lhs == __rhs); }
|
|
# 2567 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __lhs.compare(__rhs) < 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{ return __lhs.compare(__rhs) < 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator<(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __rhs.compare(__lhs) > 0; }
|
|
# 2604 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __lhs.compare(__rhs) > 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{ return __lhs.compare(__rhs) > 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator>(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __rhs.compare(__lhs) < 0; }
|
|
# 2641 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __lhs.compare(__rhs) <= 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{ return __lhs.compare(__rhs) <= 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator<=(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __rhs.compare(__lhs) >= 0; }
|
|
# 2678 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __lhs.compare(__rhs) >= 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
const _CharT* __rhs)
|
|
{ return __lhs.compare(__rhs) >= 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline bool
|
|
operator>=(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ return __rhs.compare(__lhs) <= 0; }
|
|
# 2715 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline void
|
|
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
|
|
basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{ __lhs.swap(__rhs); }
|
|
# 2733 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __is,
|
|
basic_string<_CharT, _Traits, _Alloc>& __str);
|
|
|
|
template<>
|
|
basic_istream<char>&
|
|
operator>>(basic_istream<char>& __is, basic_string<char>& __str);
|
|
# 2751 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __str)
|
|
{
|
|
|
|
|
|
return __ostream_insert(__os, __str.data(), __str.size());
|
|
}
|
|
# 2774 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_istream<_CharT, _Traits>&
|
|
getline(basic_istream<_CharT, _Traits>& __is,
|
|
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
|
|
# 2791 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
inline basic_istream<_CharT, _Traits>&
|
|
getline(basic_istream<_CharT, _Traits>& __is,
|
|
basic_string<_CharT, _Traits, _Alloc>& __str)
|
|
{ return getline(__is, __str, __is.widen('\n')); }
|
|
|
|
template<>
|
|
basic_istream<char>&
|
|
getline(basic_istream<char>& __in, basic_string<char>& __str,
|
|
char __delim);
|
|
|
|
|
|
template<>
|
|
basic_istream<wchar_t>&
|
|
getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
|
|
wchar_t __delim);
|
|
|
|
|
|
|
|
}
|
|
# 53 "/usr/include/c++/4.8.2/string" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 1 3
|
|
# 40 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
|
|
|
|
# 41 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
const _CharT
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_Rep::_S_terminal = _CharT();
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::npos;
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
|
|
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
|
|
sizeof(size_type)];
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
template<typename _InIterator>
|
|
_CharT*
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
|
|
input_iterator_tag)
|
|
{
|
|
|
|
if (__beg == __end && __a == _Alloc())
|
|
return _S_empty_rep()._M_refdata();
|
|
|
|
|
|
_CharT __buf[128];
|
|
size_type __len = 0;
|
|
while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
|
|
{
|
|
__buf[__len++] = *__beg;
|
|
++__beg;
|
|
}
|
|
_Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
|
|
_M_copy(__r->_M_refdata(), __buf, __len);
|
|
try
|
|
{
|
|
while (__beg != __end)
|
|
{
|
|
if (__len == __r->_M_capacity)
|
|
{
|
|
|
|
_Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
|
|
_M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
|
|
__r->_M_destroy(__a);
|
|
__r = __another;
|
|
}
|
|
__r->_M_refdata()[__len++] = *__beg;
|
|
++__beg;
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
__r->_M_destroy(__a);
|
|
throw;
|
|
}
|
|
__r->_M_set_length_and_sharable(__len);
|
|
return __r->_M_refdata();
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
template <typename _InIterator>
|
|
_CharT*
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
|
|
forward_iterator_tag)
|
|
{
|
|
|
|
if (__beg == __end && __a == _Alloc())
|
|
return _S_empty_rep()._M_refdata();
|
|
|
|
|
|
if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
|
|
__throw_logic_error(("basic_string::_S_construct null not valid"));
|
|
|
|
const size_type __dnew = static_cast<size_type>(std::distance(__beg,
|
|
__end));
|
|
|
|
_Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
|
|
try
|
|
{ _S_copy_chars(__r->_M_refdata(), __beg, __end); }
|
|
catch(...)
|
|
{
|
|
__r->_M_destroy(__a);
|
|
throw;
|
|
}
|
|
__r->_M_set_length_and_sharable(__dnew);
|
|
return __r->_M_refdata();
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
_CharT*
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_S_construct(size_type __n, _CharT __c, const _Alloc& __a)
|
|
{
|
|
|
|
if (__n == 0 && __a == _Alloc())
|
|
return _S_empty_rep()._M_refdata();
|
|
|
|
|
|
_Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
|
|
if (__n)
|
|
_M_assign(__r->_M_refdata(), __n, __c);
|
|
|
|
__r->_M_set_length_and_sharable(__n);
|
|
return __r->_M_refdata();
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(const basic_string& __str)
|
|
: _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
|
|
__str.get_allocator()),
|
|
__str.get_allocator())
|
|
{ }
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(const _Alloc& __a)
|
|
: _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
|
|
{ }
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(const basic_string& __str, size_type __pos, size_type __n)
|
|
: _M_dataplus(_S_construct(__str._M_data()
|
|
+ __str._M_check(__pos,
|
|
"basic_string::basic_string"),
|
|
__str._M_data() + __str._M_limit(__pos, __n)
|
|
+ __pos, _Alloc()), _Alloc())
|
|
{ }
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(const basic_string& __str, size_type __pos,
|
|
size_type __n, const _Alloc& __a)
|
|
: _M_dataplus(_S_construct(__str._M_data()
|
|
+ __str._M_check(__pos,
|
|
"basic_string::basic_string"),
|
|
__str._M_data() + __str._M_limit(__pos, __n)
|
|
+ __pos, __a), __a)
|
|
{ }
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
|
|
: _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
|
|
{ }
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(const _CharT* __s, const _Alloc& __a)
|
|
: _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
|
|
__s + npos, __a), __a)
|
|
{ }
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(size_type __n, _CharT __c, const _Alloc& __a)
|
|
: _M_dataplus(_S_construct(__n, __c, __a), __a)
|
|
{ }
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
template<typename _InputIterator>
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
|
|
: _M_dataplus(_S_construct(__beg, __end, __a), __a)
|
|
{ }
|
|
# 240 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
assign(const basic_string& __str)
|
|
{
|
|
if (_M_rep() != __str._M_rep())
|
|
{
|
|
|
|
const allocator_type __a = this->get_allocator();
|
|
_CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
|
|
_M_rep()->_M_dispose(__a);
|
|
_M_data(__tmp);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
assign(const _CharT* __s, size_type __n)
|
|
{
|
|
;
|
|
_M_check_length(this->size(), __n, "basic_string::assign");
|
|
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
|
|
return _M_replace_safe(size_type(0), this->size(), __s, __n);
|
|
else
|
|
{
|
|
|
|
const size_type __pos = __s - _M_data();
|
|
if (__pos >= __n)
|
|
_M_copy(_M_data(), __s, __n);
|
|
else if (__pos)
|
|
_M_move(_M_data(), __s, __n);
|
|
_M_rep()->_M_set_length_and_sharable(__n);
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
append(size_type __n, _CharT __c)
|
|
{
|
|
if (__n)
|
|
{
|
|
_M_check_length(size_type(0), __n, "basic_string::append");
|
|
const size_type __len = __n + this->size();
|
|
if (__len > this->capacity() || _M_rep()->_M_is_shared())
|
|
this->reserve(__len);
|
|
_M_assign(_M_data() + this->size(), __n, __c);
|
|
_M_rep()->_M_set_length_and_sharable(__len);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
append(const _CharT* __s, size_type __n)
|
|
{
|
|
;
|
|
if (__n)
|
|
{
|
|
_M_check_length(size_type(0), __n, "basic_string::append");
|
|
const size_type __len = __n + this->size();
|
|
if (__len > this->capacity() || _M_rep()->_M_is_shared())
|
|
{
|
|
if (_M_disjunct(__s))
|
|
this->reserve(__len);
|
|
else
|
|
{
|
|
const size_type __off = __s - _M_data();
|
|
this->reserve(__len);
|
|
__s = _M_data() + __off;
|
|
}
|
|
}
|
|
_M_copy(_M_data() + this->size(), __s, __n);
|
|
_M_rep()->_M_set_length_and_sharable(__len);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
append(const basic_string& __str)
|
|
{
|
|
const size_type __size = __str.size();
|
|
if (__size)
|
|
{
|
|
const size_type __len = __size + this->size();
|
|
if (__len > this->capacity() || _M_rep()->_M_is_shared())
|
|
this->reserve(__len);
|
|
_M_copy(_M_data() + this->size(), __str._M_data(), __size);
|
|
_M_rep()->_M_set_length_and_sharable(__len);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
append(const basic_string& __str, size_type __pos, size_type __n)
|
|
{
|
|
__str._M_check(__pos, "basic_string::append");
|
|
__n = __str._M_limit(__pos, __n);
|
|
if (__n)
|
|
{
|
|
const size_type __len = __n + this->size();
|
|
if (__len > this->capacity() || _M_rep()->_M_is_shared())
|
|
this->reserve(__len);
|
|
_M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
|
|
_M_rep()->_M_set_length_and_sharable(__len);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
insert(size_type __pos, const _CharT* __s, size_type __n)
|
|
{
|
|
;
|
|
_M_check(__pos, "basic_string::insert");
|
|
_M_check_length(size_type(0), __n, "basic_string::insert");
|
|
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
|
|
return _M_replace_safe(__pos, size_type(0), __s, __n);
|
|
else
|
|
{
|
|
|
|
const size_type __off = __s - _M_data();
|
|
_M_mutate(__pos, 0, __n);
|
|
__s = _M_data() + __off;
|
|
_CharT* __p = _M_data() + __pos;
|
|
if (__s + __n <= __p)
|
|
_M_copy(__p, __s, __n);
|
|
else if (__s >= __p)
|
|
_M_copy(__p, __s + __n, __n);
|
|
else
|
|
{
|
|
const size_type __nleft = __p - __s;
|
|
_M_copy(__p, __s, __nleft);
|
|
_M_copy(__p + __nleft, __p + __n, __n - __nleft);
|
|
}
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::iterator
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
erase(iterator __first, iterator __last)
|
|
{
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
const size_type __size = __last - __first;
|
|
if (__size)
|
|
{
|
|
const size_type __pos = __first - _M_ibegin();
|
|
_M_mutate(__pos, __size, size_type(0));
|
|
_M_rep()->_M_set_leaked();
|
|
return iterator(_M_data() + __pos);
|
|
}
|
|
else
|
|
return __first;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
replace(size_type __pos, size_type __n1, const _CharT* __s,
|
|
size_type __n2)
|
|
{
|
|
;
|
|
_M_check(__pos, "basic_string::replace");
|
|
__n1 = _M_limit(__pos, __n1);
|
|
_M_check_length(__n1, __n2, "basic_string::replace");
|
|
bool __left;
|
|
if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
|
|
return _M_replace_safe(__pos, __n1, __s, __n2);
|
|
else if ((__left = __s + __n2 <= _M_data() + __pos)
|
|
|| _M_data() + __pos + __n1 <= __s)
|
|
{
|
|
|
|
size_type __off = __s - _M_data();
|
|
__left ? __off : (__off += __n2 - __n1);
|
|
_M_mutate(__pos, __n1, __n2);
|
|
_M_copy(_M_data() + __pos, _M_data() + __off, __n2);
|
|
return *this;
|
|
}
|
|
else
|
|
{
|
|
|
|
const basic_string __tmp(__s, __n2);
|
|
return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
void
|
|
basic_string<_CharT, _Traits, _Alloc>::_Rep::
|
|
_M_destroy(const _Alloc& __a) throw ()
|
|
{
|
|
const size_type __size = sizeof(_Rep_base) +
|
|
(this->_M_capacity + 1) * sizeof(_CharT);
|
|
_Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
void
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_M_leak_hard()
|
|
{
|
|
|
|
if (_M_rep() == &_S_empty_rep())
|
|
return;
|
|
|
|
if (_M_rep()->_M_is_shared())
|
|
_M_mutate(0, 0, 0);
|
|
_M_rep()->_M_set_leaked();
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
void
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_M_mutate(size_type __pos, size_type __len1, size_type __len2)
|
|
{
|
|
const size_type __old_size = this->size();
|
|
const size_type __new_size = __old_size + __len2 - __len1;
|
|
const size_type __how_much = __old_size - __pos - __len1;
|
|
|
|
if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
|
|
{
|
|
|
|
const allocator_type __a = get_allocator();
|
|
_Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
|
|
|
|
if (__pos)
|
|
_M_copy(__r->_M_refdata(), _M_data(), __pos);
|
|
if (__how_much)
|
|
_M_copy(__r->_M_refdata() + __pos + __len2,
|
|
_M_data() + __pos + __len1, __how_much);
|
|
|
|
_M_rep()->_M_dispose(__a);
|
|
_M_data(__r->_M_refdata());
|
|
}
|
|
else if (__how_much && __len1 != __len2)
|
|
{
|
|
|
|
_M_move(_M_data() + __pos + __len2,
|
|
_M_data() + __pos + __len1, __how_much);
|
|
}
|
|
_M_rep()->_M_set_length_and_sharable(__new_size);
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
void
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
reserve(size_type __res)
|
|
{
|
|
if (__res != this->capacity() || _M_rep()->_M_is_shared())
|
|
{
|
|
|
|
if (__res < this->size())
|
|
__res = this->size();
|
|
const allocator_type __a = get_allocator();
|
|
_CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
|
|
_M_rep()->_M_dispose(__a);
|
|
_M_data(__tmp);
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
void
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
swap(basic_string& __s)
|
|
{
|
|
if (_M_rep()->_M_is_leaked())
|
|
_M_rep()->_M_set_sharable();
|
|
if (__s._M_rep()->_M_is_leaked())
|
|
__s._M_rep()->_M_set_sharable();
|
|
if (this->get_allocator() == __s.get_allocator())
|
|
{
|
|
_CharT* __tmp = _M_data();
|
|
_M_data(__s._M_data());
|
|
__s._M_data(__tmp);
|
|
}
|
|
|
|
else
|
|
{
|
|
const basic_string __tmp1(_M_ibegin(), _M_iend(),
|
|
__s.get_allocator());
|
|
const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
|
|
this->get_allocator());
|
|
*this = __tmp2;
|
|
__s = __tmp1;
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
|
|
basic_string<_CharT, _Traits, _Alloc>::_Rep::
|
|
_S_create(size_type __capacity, size_type __old_capacity,
|
|
const _Alloc& __alloc)
|
|
{
|
|
|
|
|
|
if (__capacity > _S_max_size)
|
|
__throw_length_error(("basic_string::_S_create"));
|
|
# 577 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
|
|
const size_type __pagesize = 4096;
|
|
const size_type __malloc_header_size = 4 * sizeof(void*);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
|
|
__capacity = 2 * __old_capacity;
|
|
|
|
|
|
|
|
|
|
size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
|
|
|
|
const size_type __adj_size = __size + __malloc_header_size;
|
|
if (__adj_size > __pagesize && __capacity > __old_capacity)
|
|
{
|
|
const size_type __extra = __pagesize - __adj_size % __pagesize;
|
|
__capacity += __extra / sizeof(_CharT);
|
|
|
|
if (__capacity > _S_max_size)
|
|
__capacity = _S_max_size;
|
|
__size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
|
|
}
|
|
|
|
|
|
|
|
void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
|
|
_Rep *__p = new (__place) _Rep;
|
|
__p->_M_capacity = __capacity;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__p->_M_set_sharable();
|
|
return __p;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
_CharT*
|
|
basic_string<_CharT, _Traits, _Alloc>::_Rep::
|
|
_M_clone(const _Alloc& __alloc, size_type __res)
|
|
{
|
|
|
|
const size_type __requested_cap = this->_M_length + __res;
|
|
_Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
|
|
__alloc);
|
|
if (this->_M_length)
|
|
_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
|
|
|
|
__r->_M_set_length_and_sharable(this->_M_length);
|
|
return __r->_M_refdata();
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
void
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
resize(size_type __n, _CharT __c)
|
|
{
|
|
const size_type __size = this->size();
|
|
_M_check_length(__size, __n, "basic_string::resize");
|
|
if (__size < __n)
|
|
this->append(__n - __size, __c);
|
|
else if (__n < __size)
|
|
this->erase(__n);
|
|
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
template<typename _InputIterator>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
|
|
_InputIterator __k2, __false_type)
|
|
{
|
|
const basic_string __s(__k1, __k2);
|
|
const size_type __n1 = __i2 - __i1;
|
|
_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
|
|
return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
|
|
__s.size());
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
|
|
_CharT __c)
|
|
{
|
|
_M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
|
|
_M_mutate(__pos1, __n1, __n2);
|
|
if (__n2)
|
|
_M_assign(_M_data() + __pos1, __n2, __c);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>&
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
_M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
|
|
size_type __n2)
|
|
{
|
|
_M_mutate(__pos1, __n1, __n2);
|
|
if (__n2)
|
|
_M_copy(_M_data() + __pos1, __s, __n2);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>
|
|
operator+(const _CharT* __lhs,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{
|
|
;
|
|
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
|
typedef typename __string_type::size_type __size_type;
|
|
const __size_type __len = _Traits::length(__lhs);
|
|
__string_type __str;
|
|
__str.reserve(__len + __rhs.size());
|
|
__str.append(__lhs, __len);
|
|
__str.append(__rhs);
|
|
return __str;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_string<_CharT, _Traits, _Alloc>
|
|
operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
|
|
{
|
|
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
|
typedef typename __string_type::size_type __size_type;
|
|
__string_type __str;
|
|
const __size_type __len = __rhs.size();
|
|
__str.reserve(__len + 1);
|
|
__str.append(__size_type(1), __lhs);
|
|
__str.append(__rhs);
|
|
return __str;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
copy(_CharT* __s, size_type __n, size_type __pos) const
|
|
{
|
|
_M_check(__pos, "basic_string::copy");
|
|
__n = _M_limit(__pos, __n);
|
|
;
|
|
if (__n)
|
|
_M_copy(__s, _M_data() + __pos, __n);
|
|
|
|
return __n;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find(const _CharT* __s, size_type __pos, size_type __n) const
|
|
{
|
|
;
|
|
const size_type __size = this->size();
|
|
const _CharT* __data = _M_data();
|
|
|
|
if (__n == 0)
|
|
return __pos <= __size ? __pos : npos;
|
|
|
|
if (__n <= __size)
|
|
{
|
|
for (; __pos <= __size - __n; ++__pos)
|
|
if (traits_type::eq(__data[__pos], __s[0])
|
|
&& traits_type::compare(__data + __pos + 1,
|
|
__s + 1, __n - 1) == 0)
|
|
return __pos;
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find(_CharT __c, size_type __pos) const
|
|
{
|
|
size_type __ret = npos;
|
|
const size_type __size = this->size();
|
|
if (__pos < __size)
|
|
{
|
|
const _CharT* __data = _M_data();
|
|
const size_type __n = __size - __pos;
|
|
const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
|
|
if (__p)
|
|
__ret = __p - __data;
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
rfind(const _CharT* __s, size_type __pos, size_type __n) const
|
|
{
|
|
;
|
|
const size_type __size = this->size();
|
|
if (__n <= __size)
|
|
{
|
|
__pos = std::min(size_type(__size - __n), __pos);
|
|
const _CharT* __data = _M_data();
|
|
do
|
|
{
|
|
if (traits_type::compare(__data + __pos, __s, __n) == 0)
|
|
return __pos;
|
|
}
|
|
while (__pos-- > 0);
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
rfind(_CharT __c, size_type __pos) const
|
|
{
|
|
size_type __size = this->size();
|
|
if (__size)
|
|
{
|
|
if (--__size > __pos)
|
|
__size = __pos;
|
|
for (++__size; __size-- > 0; )
|
|
if (traits_type::eq(_M_data()[__size], __c))
|
|
return __size;
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
|
|
{
|
|
;
|
|
for (; __n && __pos < this->size(); ++__pos)
|
|
{
|
|
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
|
|
if (__p)
|
|
return __pos;
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
|
|
{
|
|
;
|
|
size_type __size = this->size();
|
|
if (__size && __n)
|
|
{
|
|
if (--__size > __pos)
|
|
__size = __pos;
|
|
do
|
|
{
|
|
if (traits_type::find(__s, __n, _M_data()[__size]))
|
|
return __size;
|
|
}
|
|
while (__size-- != 0);
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
|
|
{
|
|
;
|
|
for (; __pos < this->size(); ++__pos)
|
|
if (!traits_type::find(__s, __n, _M_data()[__pos]))
|
|
return __pos;
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find_first_not_of(_CharT __c, size_type __pos) const
|
|
{
|
|
for (; __pos < this->size(); ++__pos)
|
|
if (!traits_type::eq(_M_data()[__pos], __c))
|
|
return __pos;
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
|
|
{
|
|
;
|
|
size_type __size = this->size();
|
|
if (__size)
|
|
{
|
|
if (--__size > __pos)
|
|
__size = __pos;
|
|
do
|
|
{
|
|
if (!traits_type::find(__s, __n, _M_data()[__size]))
|
|
return __size;
|
|
}
|
|
while (__size--);
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
typename basic_string<_CharT, _Traits, _Alloc>::size_type
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
find_last_not_of(_CharT __c, size_type __pos) const
|
|
{
|
|
size_type __size = this->size();
|
|
if (__size)
|
|
{
|
|
if (--__size > __pos)
|
|
__size = __pos;
|
|
do
|
|
{
|
|
if (!traits_type::eq(_M_data()[__size], __c))
|
|
return __size;
|
|
}
|
|
while (__size--);
|
|
}
|
|
return npos;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
int
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
compare(size_type __pos, size_type __n, const basic_string& __str) const
|
|
{
|
|
_M_check(__pos, "basic_string::compare");
|
|
__n = _M_limit(__pos, __n);
|
|
const size_type __osize = __str.size();
|
|
const size_type __len = std::min(__n, __osize);
|
|
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
|
|
if (!__r)
|
|
__r = _S_compare(__n, __osize);
|
|
return __r;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
int
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
compare(size_type __pos1, size_type __n1, const basic_string& __str,
|
|
size_type __pos2, size_type __n2) const
|
|
{
|
|
_M_check(__pos1, "basic_string::compare");
|
|
__str._M_check(__pos2, "basic_string::compare");
|
|
__n1 = _M_limit(__pos1, __n1);
|
|
__n2 = __str._M_limit(__pos2, __n2);
|
|
const size_type __len = std::min(__n1, __n2);
|
|
int __r = traits_type::compare(_M_data() + __pos1,
|
|
__str.data() + __pos2, __len);
|
|
if (!__r)
|
|
__r = _S_compare(__n1, __n2);
|
|
return __r;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
int
|
|
basic_string<_CharT, _Traits, _Alloc>::
|
|
compare(const _CharT* __s) const
|
|
{
|
|
;
|
|
const size_type __size = this->size();
|
|
const size_type __osize = traits_type::length(__s);
|
|
const size_type __len = std::min(__size, __osize);
|
|
int __r = traits_type::compare(_M_data(), __s, __len);
|
|
if (!__r)
|
|
__r = _S_compare(__size, __osize);
|
|
return __r;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
int
|
|
basic_string <_CharT, _Traits, _Alloc>::
|
|
compare(size_type __pos, size_type __n1, const _CharT* __s) const
|
|
{
|
|
;
|
|
_M_check(__pos, "basic_string::compare");
|
|
__n1 = _M_limit(__pos, __n1);
|
|
const size_type __osize = traits_type::length(__s);
|
|
const size_type __len = std::min(__n1, __osize);
|
|
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
|
|
if (!__r)
|
|
__r = _S_compare(__n1, __osize);
|
|
return __r;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
int
|
|
basic_string <_CharT, _Traits, _Alloc>::
|
|
compare(size_type __pos, size_type __n1, const _CharT* __s,
|
|
size_type __n2) const
|
|
{
|
|
;
|
|
_M_check(__pos, "basic_string::compare");
|
|
__n1 = _M_limit(__pos, __n1);
|
|
const size_type __len = std::min(__n1, __n2);
|
|
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
|
|
if (!__r)
|
|
__r = _S_compare(__n1, __n2);
|
|
return __r;
|
|
}
|
|
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __in,
|
|
basic_string<_CharT, _Traits, _Alloc>& __str)
|
|
{
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
|
typedef typename __istream_type::ios_base __ios_base;
|
|
typedef typename __istream_type::int_type __int_type;
|
|
typedef typename __string_type::size_type __size_type;
|
|
typedef ctype<_CharT> __ctype_type;
|
|
typedef typename __ctype_type::ctype_base __ctype_base;
|
|
|
|
__size_type __extracted = 0;
|
|
typename __ios_base::iostate __err = __ios_base::goodbit;
|
|
typename __istream_type::sentry __cerb(__in, false);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
|
|
__str.erase();
|
|
_CharT __buf[128];
|
|
__size_type __len = 0;
|
|
const streamsize __w = __in.width();
|
|
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
|
|
: __str.max_size();
|
|
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
|
|
const __int_type __eof = _Traits::eof();
|
|
__int_type __c = __in.rdbuf()->sgetc();
|
|
|
|
while (__extracted < __n
|
|
&& !_Traits::eq_int_type(__c, __eof)
|
|
&& !__ct.is(__ctype_base::space,
|
|
_Traits::to_char_type(__c)))
|
|
{
|
|
if (__len == sizeof(__buf) / sizeof(_CharT))
|
|
{
|
|
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
|
|
__len = 0;
|
|
}
|
|
__buf[__len++] = _Traits::to_char_type(__c);
|
|
++__extracted;
|
|
__c = __in.rdbuf()->snextc();
|
|
}
|
|
__str.append(__buf, __len);
|
|
|
|
if (_Traits::eq_int_type(__c, __eof))
|
|
__err |= __ios_base::eofbit;
|
|
__in.width(0);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__in._M_setstate(__ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{
|
|
|
|
|
|
|
|
__in._M_setstate(__ios_base::badbit);
|
|
}
|
|
}
|
|
|
|
if (!__extracted)
|
|
__err |= __ios_base::failbit;
|
|
if (__err)
|
|
__in.setstate(__err);
|
|
return __in;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
basic_istream<_CharT, _Traits>&
|
|
getline(basic_istream<_CharT, _Traits>& __in,
|
|
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
|
|
{
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
|
|
typedef typename __istream_type::ios_base __ios_base;
|
|
typedef typename __istream_type::int_type __int_type;
|
|
typedef typename __string_type::size_type __size_type;
|
|
|
|
__size_type __extracted = 0;
|
|
const __size_type __n = __str.max_size();
|
|
typename __ios_base::iostate __err = __ios_base::goodbit;
|
|
typename __istream_type::sentry __cerb(__in, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
__str.erase();
|
|
const __int_type __idelim = _Traits::to_int_type(__delim);
|
|
const __int_type __eof = _Traits::eof();
|
|
__int_type __c = __in.rdbuf()->sgetc();
|
|
|
|
while (__extracted < __n
|
|
&& !_Traits::eq_int_type(__c, __eof)
|
|
&& !_Traits::eq_int_type(__c, __idelim))
|
|
{
|
|
__str += _Traits::to_char_type(__c);
|
|
++__extracted;
|
|
__c = __in.rdbuf()->snextc();
|
|
}
|
|
|
|
if (_Traits::eq_int_type(__c, __eof))
|
|
__err |= __ios_base::eofbit;
|
|
else if (_Traits::eq_int_type(__c, __idelim))
|
|
{
|
|
++__extracted;
|
|
__in.rdbuf()->sbumpc();
|
|
}
|
|
else
|
|
__err |= __ios_base::failbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__in._M_setstate(__ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{
|
|
|
|
|
|
|
|
__in._M_setstate(__ios_base::badbit);
|
|
}
|
|
}
|
|
if (!__extracted)
|
|
__err |= __ios_base::failbit;
|
|
if (__err)
|
|
__in.setstate(__err);
|
|
return __in;
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class basic_string<char>;
|
|
extern template
|
|
basic_istream<char>&
|
|
operator>>(basic_istream<char>&, string&);
|
|
extern template
|
|
basic_ostream<char>&
|
|
operator<<(basic_ostream<char>&, const string&);
|
|
extern template
|
|
basic_istream<char>&
|
|
getline(basic_istream<char>&, string&, char);
|
|
extern template
|
|
basic_istream<char>&
|
|
getline(basic_istream<char>&, string&);
|
|
|
|
|
|
extern template class basic_string<wchar_t>;
|
|
extern template
|
|
basic_istream<wchar_t>&
|
|
operator>>(basic_istream<wchar_t>&, wstring&);
|
|
extern template
|
|
basic_ostream<wchar_t>&
|
|
operator<<(basic_ostream<wchar_t>&, const wstring&);
|
|
extern template
|
|
basic_istream<wchar_t>&
|
|
getline(basic_istream<wchar_t>&, wstring&, wchar_t);
|
|
extern template
|
|
basic_istream<wchar_t>&
|
|
getline(basic_istream<wchar_t>&, wstring&);
|
|
|
|
|
|
|
|
|
|
}
|
|
# 54 "/usr/include/c++/4.8.2/string" 2 3
|
|
# 41 "/usr/include/c++/4.8.2/bits/locale_classes.h" 2 3
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 62 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
class locale
|
|
{
|
|
public:
|
|
|
|
|
|
typedef int category;
|
|
|
|
|
|
class facet;
|
|
class id;
|
|
class _Impl;
|
|
|
|
friend class facet;
|
|
friend class _Impl;
|
|
|
|
template<typename _Facet>
|
|
friend bool
|
|
has_facet(const locale&) throw();
|
|
|
|
template<typename _Facet>
|
|
friend const _Facet&
|
|
use_facet(const locale&);
|
|
|
|
template<typename _Cache>
|
|
friend struct __use_cache;
|
|
# 98 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
static const category none = 0;
|
|
static const category ctype = 1L << 0;
|
|
static const category numeric = 1L << 1;
|
|
static const category collate = 1L << 2;
|
|
static const category time = 1L << 3;
|
|
static const category monetary = 1L << 4;
|
|
static const category messages = 1L << 5;
|
|
static const category all = (ctype | numeric | collate |
|
|
time | monetary | messages);
|
|
# 117 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
locale() throw();
|
|
# 126 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
locale(const locale& __other) throw();
|
|
# 136 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
explicit
|
|
locale(const char* __s);
|
|
# 151 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
locale(const locale& __base, const char* __s, category __cat);
|
|
# 164 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
locale(const locale& __base, const locale& __add, category __cat);
|
|
# 177 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
template<typename _Facet>
|
|
locale(const locale& __other, _Facet* __f);
|
|
|
|
|
|
~locale() throw();
|
|
# 191 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
const locale&
|
|
operator=(const locale& __other) throw();
|
|
# 206 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
template<typename _Facet>
|
|
locale
|
|
combine(const locale& __other) const;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
string
|
|
name() const;
|
|
# 225 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
bool
|
|
operator==(const locale& __other) const throw();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
operator!=(const locale& __other) const throw()
|
|
{ return !(this->operator==(__other)); }
|
|
# 253 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
template<typename _Char, typename _Traits, typename _Alloc>
|
|
bool
|
|
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
|
|
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
|
|
# 269 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
static locale
|
|
global(const locale& __loc);
|
|
|
|
|
|
|
|
|
|
static const locale&
|
|
classic();
|
|
|
|
private:
|
|
|
|
_Impl* _M_impl;
|
|
|
|
|
|
static _Impl* _S_classic;
|
|
|
|
|
|
static _Impl* _S_global;
|
|
|
|
|
|
|
|
|
|
|
|
static const char* const* const _S_categories;
|
|
# 304 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
enum { _S_categories_size = 6 + 6 };
|
|
|
|
|
|
static __gthread_once_t _S_once;
|
|
|
|
|
|
explicit
|
|
locale(_Impl*) throw();
|
|
|
|
static void
|
|
_S_initialize();
|
|
|
|
static void
|
|
_S_initialize_once() throw();
|
|
|
|
static category
|
|
_S_normalize_category(category);
|
|
|
|
void
|
|
_M_coalesce(const locale& __base, const locale& __add, category __cat);
|
|
};
|
|
# 338 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
class locale::facet
|
|
{
|
|
private:
|
|
friend class locale;
|
|
friend class locale::_Impl;
|
|
|
|
mutable _Atomic_word _M_refcount;
|
|
|
|
|
|
static __c_locale _S_c_locale;
|
|
|
|
|
|
static const char _S_c_name[2];
|
|
|
|
|
|
static __gthread_once_t _S_once;
|
|
|
|
|
|
static void
|
|
_S_initialize_once();
|
|
|
|
protected:
|
|
# 369 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
explicit
|
|
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
|
|
{ }
|
|
|
|
|
|
virtual
|
|
~facet();
|
|
|
|
static void
|
|
_S_create_c_locale(__c_locale& __cloc, const char* __s,
|
|
__c_locale __old = 0);
|
|
|
|
static __c_locale
|
|
_S_clone_c_locale(__c_locale& __cloc) throw();
|
|
|
|
static void
|
|
_S_destroy_c_locale(__c_locale& __cloc);
|
|
|
|
static __c_locale
|
|
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
|
|
|
|
|
|
|
|
static __c_locale
|
|
_S_get_c_locale();
|
|
|
|
__attribute__ ((__const__)) static const char*
|
|
_S_get_c_name() throw();
|
|
|
|
private:
|
|
void
|
|
_M_add_reference() const throw()
|
|
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
|
|
|
|
void
|
|
_M_remove_reference() const throw()
|
|
{
|
|
|
|
;
|
|
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
|
|
{
|
|
;
|
|
try
|
|
{ delete this; }
|
|
catch(...)
|
|
{ }
|
|
}
|
|
}
|
|
|
|
facet(const facet&);
|
|
|
|
facet&
|
|
operator=(const facet&);
|
|
};
|
|
# 436 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
class locale::id
|
|
{
|
|
private:
|
|
friend class locale;
|
|
friend class locale::_Impl;
|
|
|
|
template<typename _Facet>
|
|
friend const _Facet&
|
|
use_facet(const locale&);
|
|
|
|
template<typename _Facet>
|
|
friend bool
|
|
has_facet(const locale&) throw();
|
|
|
|
|
|
|
|
|
|
mutable size_t _M_index;
|
|
|
|
|
|
static _Atomic_word _S_refcount;
|
|
|
|
void
|
|
operator=(const id&);
|
|
|
|
id(const id&);
|
|
|
|
public:
|
|
|
|
|
|
|
|
id() { }
|
|
|
|
size_t
|
|
_M_id() const throw();
|
|
};
|
|
|
|
|
|
|
|
class locale::_Impl
|
|
{
|
|
public:
|
|
|
|
friend class locale;
|
|
friend class locale::facet;
|
|
|
|
template<typename _Facet>
|
|
friend bool
|
|
has_facet(const locale&) throw();
|
|
|
|
template<typename _Facet>
|
|
friend const _Facet&
|
|
use_facet(const locale&);
|
|
|
|
template<typename _Cache>
|
|
friend struct __use_cache;
|
|
|
|
private:
|
|
|
|
_Atomic_word _M_refcount;
|
|
const facet** _M_facets;
|
|
size_t _M_facets_size;
|
|
const facet** _M_caches;
|
|
char** _M_names;
|
|
static const locale::id* const _S_id_ctype[];
|
|
static const locale::id* const _S_id_numeric[];
|
|
static const locale::id* const _S_id_collate[];
|
|
static const locale::id* const _S_id_time[];
|
|
static const locale::id* const _S_id_monetary[];
|
|
static const locale::id* const _S_id_messages[];
|
|
static const locale::id* const* const _S_facet_categories[];
|
|
|
|
void
|
|
_M_add_reference() throw()
|
|
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
|
|
|
|
void
|
|
_M_remove_reference() throw()
|
|
{
|
|
|
|
;
|
|
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
|
|
{
|
|
;
|
|
try
|
|
{ delete this; }
|
|
catch(...)
|
|
{ }
|
|
}
|
|
}
|
|
|
|
_Impl(const _Impl&, size_t);
|
|
_Impl(const char*, size_t);
|
|
_Impl(size_t) throw();
|
|
|
|
~_Impl() throw();
|
|
|
|
_Impl(const _Impl&);
|
|
|
|
void
|
|
operator=(const _Impl&);
|
|
|
|
bool
|
|
_M_check_same_name()
|
|
{
|
|
bool __ret = true;
|
|
if (_M_names[1])
|
|
|
|
for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
|
|
__ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
|
|
return __ret;
|
|
}
|
|
|
|
void
|
|
_M_replace_categories(const _Impl*, category);
|
|
|
|
void
|
|
_M_replace_category(const _Impl*, const locale::id* const*);
|
|
|
|
void
|
|
_M_replace_facet(const _Impl*, const locale::id*);
|
|
|
|
void
|
|
_M_install_facet(const locale::id*, const facet*);
|
|
|
|
template<typename _Facet>
|
|
void
|
|
_M_init_facet(_Facet* __facet)
|
|
{ _M_install_facet(&_Facet::id, __facet); }
|
|
|
|
void
|
|
_M_install_cache(const facet*, size_t);
|
|
};
|
|
# 583 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
template<typename _CharT>
|
|
class collate : public locale::facet
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef basic_string<_CharT> string_type;
|
|
|
|
|
|
protected:
|
|
|
|
|
|
__c_locale _M_c_locale_collate;
|
|
|
|
public:
|
|
|
|
static locale::id id;
|
|
# 610 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
explicit
|
|
collate(size_t __refs = 0)
|
|
: facet(__refs), _M_c_locale_collate(_S_get_c_locale())
|
|
{ }
|
|
# 624 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
explicit
|
|
collate(__c_locale __cloc, size_t __refs = 0)
|
|
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
|
|
{ }
|
|
# 641 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
int
|
|
compare(const _CharT* __lo1, const _CharT* __hi1,
|
|
const _CharT* __lo2, const _CharT* __hi2) const
|
|
{ return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
|
|
# 660 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
string_type
|
|
transform(const _CharT* __lo, const _CharT* __hi) const
|
|
{ return this->do_transform(__lo, __hi); }
|
|
# 674 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
long
|
|
hash(const _CharT* __lo, const _CharT* __hi) const
|
|
{ return this->do_hash(__lo, __hi); }
|
|
|
|
|
|
int
|
|
_M_compare(const _CharT*, const _CharT*) const throw();
|
|
|
|
size_t
|
|
_M_transform(_CharT*, const _CharT*, size_t) const throw();
|
|
|
|
protected:
|
|
|
|
virtual
|
|
~collate()
|
|
{ _S_destroy_c_locale(_M_c_locale_collate); }
|
|
# 703 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
virtual int
|
|
do_compare(const _CharT* __lo1, const _CharT* __hi1,
|
|
const _CharT* __lo2, const _CharT* __hi2) const;
|
|
# 717 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
virtual string_type
|
|
do_transform(const _CharT* __lo, const _CharT* __hi) const;
|
|
# 730 "/usr/include/c++/4.8.2/bits/locale_classes.h" 3
|
|
virtual long
|
|
do_hash(const _CharT* __lo, const _CharT* __hi) const;
|
|
};
|
|
|
|
template<typename _CharT>
|
|
locale::id collate<_CharT>::id;
|
|
|
|
|
|
template<>
|
|
int
|
|
collate<char>::_M_compare(const char*, const char*) const throw();
|
|
|
|
template<>
|
|
size_t
|
|
collate<char>::_M_transform(char*, const char*, size_t) const throw();
|
|
|
|
|
|
template<>
|
|
int
|
|
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
|
|
|
|
template<>
|
|
size_t
|
|
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
class collate_byname : public collate<_CharT>
|
|
{
|
|
public:
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef basic_string<_CharT> string_type;
|
|
|
|
|
|
explicit
|
|
collate_byname(const char* __s, size_t __refs = 0)
|
|
: collate<_CharT>(__refs)
|
|
{
|
|
if (__builtin_strcmp(__s, "C") != 0
|
|
&& __builtin_strcmp(__s, "POSIX") != 0)
|
|
{
|
|
this->_S_destroy_c_locale(this->_M_c_locale_collate);
|
|
this->_S_create_c_locale(this->_M_c_locale_collate, __s);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
virtual
|
|
~collate_byname() { }
|
|
};
|
|
|
|
|
|
}
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _Facet>
|
|
locale::
|
|
locale(const locale& __other, _Facet* __f)
|
|
{
|
|
_M_impl = new _Impl(*__other._M_impl, 1);
|
|
|
|
try
|
|
{ _M_impl->_M_install_facet(&_Facet::id, __f); }
|
|
catch(...)
|
|
{
|
|
_M_impl->_M_remove_reference();
|
|
throw;
|
|
}
|
|
delete [] _M_impl->_M_names[0];
|
|
_M_impl->_M_names[0] = 0;
|
|
}
|
|
|
|
template<typename _Facet>
|
|
locale
|
|
locale::
|
|
combine(const locale& __other) const
|
|
{
|
|
_Impl* __tmp = new _Impl(*_M_impl, 1);
|
|
try
|
|
{
|
|
__tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
|
|
}
|
|
catch(...)
|
|
{
|
|
__tmp->_M_remove_reference();
|
|
throw;
|
|
}
|
|
return locale(__tmp);
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits, typename _Alloc>
|
|
bool
|
|
locale::
|
|
operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
|
|
const basic_string<_CharT, _Traits, _Alloc>& __s2) const
|
|
{
|
|
typedef std::collate<_CharT> __collate_type;
|
|
const __collate_type& __collate = use_facet<__collate_type>(*this);
|
|
return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
|
|
__s2.data(), __s2.data() + __s2.length()) < 0);
|
|
}
|
|
# 102 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
|
|
template<typename _Facet>
|
|
bool
|
|
has_facet(const locale& __loc) throw()
|
|
{
|
|
const size_t __i = _Facet::id._M_id();
|
|
const locale::facet** __facets = __loc._M_impl->_M_facets;
|
|
return (__i < __loc._M_impl->_M_facets_size
|
|
|
|
&& dynamic_cast<const _Facet*>(__facets[__i]));
|
|
|
|
|
|
|
|
}
|
|
# 130 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
|
|
template<typename _Facet>
|
|
const _Facet&
|
|
use_facet(const locale& __loc)
|
|
{
|
|
const size_t __i = _Facet::id._M_id();
|
|
const locale::facet** __facets = __loc._M_impl->_M_facets;
|
|
if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
|
|
__throw_bad_cast();
|
|
|
|
return dynamic_cast<const _Facet&>(*__facets[__i]);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
int
|
|
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
|
|
{ return 0; }
|
|
|
|
|
|
template<typename _CharT>
|
|
size_t
|
|
collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
|
|
{ return 0; }
|
|
|
|
template<typename _CharT>
|
|
int
|
|
collate<_CharT>::
|
|
do_compare(const _CharT* __lo1, const _CharT* __hi1,
|
|
const _CharT* __lo2, const _CharT* __hi2) const
|
|
{
|
|
|
|
|
|
const string_type __one(__lo1, __hi1);
|
|
const string_type __two(__lo2, __hi2);
|
|
|
|
const _CharT* __p = __one.c_str();
|
|
const _CharT* __pend = __one.data() + __one.length();
|
|
const _CharT* __q = __two.c_str();
|
|
const _CharT* __qend = __two.data() + __two.length();
|
|
|
|
|
|
|
|
|
|
for (;;)
|
|
{
|
|
const int __res = _M_compare(__p, __q);
|
|
if (__res)
|
|
return __res;
|
|
|
|
__p += char_traits<_CharT>::length(__p);
|
|
__q += char_traits<_CharT>::length(__q);
|
|
if (__p == __pend && __q == __qend)
|
|
return 0;
|
|
else if (__p == __pend)
|
|
return -1;
|
|
else if (__q == __qend)
|
|
return 1;
|
|
|
|
__p++;
|
|
__q++;
|
|
}
|
|
}
|
|
|
|
template<typename _CharT>
|
|
typename collate<_CharT>::string_type
|
|
collate<_CharT>::
|
|
do_transform(const _CharT* __lo, const _CharT* __hi) const
|
|
{
|
|
string_type __ret;
|
|
|
|
|
|
const string_type __str(__lo, __hi);
|
|
|
|
const _CharT* __p = __str.c_str();
|
|
const _CharT* __pend = __str.data() + __str.length();
|
|
|
|
size_t __len = (__hi - __lo) * 2;
|
|
|
|
_CharT* __c = new _CharT[__len];
|
|
|
|
try
|
|
{
|
|
|
|
|
|
|
|
for (;;)
|
|
{
|
|
|
|
size_t __res = _M_transform(__c, __p, __len);
|
|
|
|
|
|
if (__res >= __len)
|
|
{
|
|
__len = __res + 1;
|
|
delete [] __c, __c = 0;
|
|
__c = new _CharT[__len];
|
|
__res = _M_transform(__c, __p, __len);
|
|
}
|
|
|
|
__ret.append(__c, __res);
|
|
__p += char_traits<_CharT>::length(__p);
|
|
if (__p == __pend)
|
|
break;
|
|
|
|
__p++;
|
|
__ret.push_back(_CharT());
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
delete [] __c;
|
|
throw;
|
|
}
|
|
|
|
delete [] __c;
|
|
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT>
|
|
long
|
|
collate<_CharT>::
|
|
do_hash(const _CharT* __lo, const _CharT* __hi) const
|
|
{
|
|
unsigned long __val = 0;
|
|
for (; __lo < __hi; ++__lo)
|
|
__val =
|
|
*__lo + ((__val << 7)
|
|
| (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
|
|
__digits - 7)));
|
|
return static_cast<long>(__val);
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class collate<char>;
|
|
extern template class collate_byname<char>;
|
|
|
|
extern template
|
|
const collate<char>&
|
|
use_facet<collate<char> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<collate<char> >(const locale&);
|
|
|
|
|
|
extern template class collate<wchar_t>;
|
|
extern template class collate_byname<wchar_t>;
|
|
|
|
extern template
|
|
const collate<wchar_t>&
|
|
use_facet<collate<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<collate<wchar_t> >(const locale&);
|
|
|
|
|
|
|
|
|
|
}
|
|
# 788 "/usr/include/c++/4.8.2/bits/locale_classes.h" 2 3
|
|
# 42 "/usr/include/c++/4.8.2/bits/ios_base.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
enum _Ios_Fmtflags
|
|
{
|
|
_S_boolalpha = 1L << 0,
|
|
_S_dec = 1L << 1,
|
|
_S_fixed = 1L << 2,
|
|
_S_hex = 1L << 3,
|
|
_S_internal = 1L << 4,
|
|
_S_left = 1L << 5,
|
|
_S_oct = 1L << 6,
|
|
_S_right = 1L << 7,
|
|
_S_scientific = 1L << 8,
|
|
_S_showbase = 1L << 9,
|
|
_S_showpoint = 1L << 10,
|
|
_S_showpos = 1L << 11,
|
|
_S_skipws = 1L << 12,
|
|
_S_unitbuf = 1L << 13,
|
|
_S_uppercase = 1L << 14,
|
|
_S_adjustfield = _S_left | _S_right | _S_internal,
|
|
_S_basefield = _S_dec | _S_oct | _S_hex,
|
|
_S_floatfield = _S_scientific | _S_fixed,
|
|
_S_ios_fmtflags_end = 1L << 16
|
|
};
|
|
|
|
inline _Ios_Fmtflags
|
|
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
|
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
|
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
|
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator~(_Ios_Fmtflags __a)
|
|
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
|
|
|
|
inline const _Ios_Fmtflags&
|
|
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
|
{ return __a = __a | __b; }
|
|
|
|
inline const _Ios_Fmtflags&
|
|
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
|
{ return __a = __a & __b; }
|
|
|
|
inline const _Ios_Fmtflags&
|
|
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
|
{ return __a = __a ^ __b; }
|
|
|
|
|
|
enum _Ios_Openmode
|
|
{
|
|
_S_app = 1L << 0,
|
|
_S_ate = 1L << 1,
|
|
_S_bin = 1L << 2,
|
|
_S_in = 1L << 3,
|
|
_S_out = 1L << 4,
|
|
_S_trunc = 1L << 5,
|
|
_S_ios_openmode_end = 1L << 16
|
|
};
|
|
|
|
inline _Ios_Openmode
|
|
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
|
|
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Openmode
|
|
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
|
|
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Openmode
|
|
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
|
|
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Openmode
|
|
operator~(_Ios_Openmode __a)
|
|
{ return _Ios_Openmode(~static_cast<int>(__a)); }
|
|
|
|
inline const _Ios_Openmode&
|
|
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
|
{ return __a = __a | __b; }
|
|
|
|
inline const _Ios_Openmode&
|
|
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
|
{ return __a = __a & __b; }
|
|
|
|
inline const _Ios_Openmode&
|
|
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
|
{ return __a = __a ^ __b; }
|
|
|
|
|
|
enum _Ios_Iostate
|
|
{
|
|
_S_goodbit = 0,
|
|
_S_badbit = 1L << 0,
|
|
_S_eofbit = 1L << 1,
|
|
_S_failbit = 1L << 2,
|
|
_S_ios_iostate_end = 1L << 16
|
|
};
|
|
|
|
inline _Ios_Iostate
|
|
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
|
|
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Iostate
|
|
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
|
|
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Iostate
|
|
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
|
|
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Iostate
|
|
operator~(_Ios_Iostate __a)
|
|
{ return _Ios_Iostate(~static_cast<int>(__a)); }
|
|
|
|
inline const _Ios_Iostate&
|
|
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
|
{ return __a = __a | __b; }
|
|
|
|
inline const _Ios_Iostate&
|
|
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
|
{ return __a = __a & __b; }
|
|
|
|
inline const _Ios_Iostate&
|
|
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
|
{ return __a = __a ^ __b; }
|
|
|
|
|
|
enum _Ios_Seekdir
|
|
{
|
|
_S_beg = 0,
|
|
_S_cur = 1,
|
|
_S_end = 2,
|
|
_S_ios_seekdir_end = 1L << 16
|
|
};
|
|
# 199 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
class ios_base
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class failure : public exception
|
|
{
|
|
public:
|
|
|
|
|
|
explicit
|
|
failure(const string& __str) throw();
|
|
|
|
|
|
|
|
virtual
|
|
~failure() throw();
|
|
|
|
virtual const char*
|
|
what() const throw();
|
|
|
|
private:
|
|
string _M_msg;
|
|
};
|
|
# 255 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
typedef _Ios_Fmtflags fmtflags;
|
|
|
|
|
|
static const fmtflags boolalpha = _S_boolalpha;
|
|
|
|
|
|
static const fmtflags dec = _S_dec;
|
|
|
|
|
|
static const fmtflags fixed = _S_fixed;
|
|
|
|
|
|
static const fmtflags hex = _S_hex;
|
|
|
|
|
|
|
|
|
|
static const fmtflags internal = _S_internal;
|
|
|
|
|
|
|
|
static const fmtflags left = _S_left;
|
|
|
|
|
|
static const fmtflags oct = _S_oct;
|
|
|
|
|
|
|
|
static const fmtflags right = _S_right;
|
|
|
|
|
|
static const fmtflags scientific = _S_scientific;
|
|
|
|
|
|
|
|
static const fmtflags showbase = _S_showbase;
|
|
|
|
|
|
|
|
static const fmtflags showpoint = _S_showpoint;
|
|
|
|
|
|
static const fmtflags showpos = _S_showpos;
|
|
|
|
|
|
static const fmtflags skipws = _S_skipws;
|
|
|
|
|
|
static const fmtflags unitbuf = _S_unitbuf;
|
|
|
|
|
|
|
|
static const fmtflags uppercase = _S_uppercase;
|
|
|
|
|
|
static const fmtflags adjustfield = _S_adjustfield;
|
|
|
|
|
|
static const fmtflags basefield = _S_basefield;
|
|
|
|
|
|
static const fmtflags floatfield = _S_floatfield;
|
|
# 330 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
typedef _Ios_Iostate iostate;
|
|
|
|
|
|
|
|
static const iostate badbit = _S_badbit;
|
|
|
|
|
|
static const iostate eofbit = _S_eofbit;
|
|
|
|
|
|
|
|
|
|
static const iostate failbit = _S_failbit;
|
|
|
|
|
|
static const iostate goodbit = _S_goodbit;
|
|
# 361 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
typedef _Ios_Openmode openmode;
|
|
|
|
|
|
static const openmode app = _S_app;
|
|
|
|
|
|
static const openmode ate = _S_ate;
|
|
|
|
|
|
|
|
|
|
static const openmode binary = _S_bin;
|
|
|
|
|
|
static const openmode in = _S_in;
|
|
|
|
|
|
static const openmode out = _S_out;
|
|
|
|
|
|
static const openmode trunc = _S_trunc;
|
|
# 393 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
typedef _Ios_Seekdir seekdir;
|
|
|
|
|
|
static const seekdir beg = _S_beg;
|
|
|
|
|
|
static const seekdir cur = _S_cur;
|
|
|
|
|
|
static const seekdir end = _S_end;
|
|
|
|
|
|
typedef int io_state;
|
|
typedef int open_mode;
|
|
typedef int seek_dir;
|
|
|
|
typedef std::streampos streampos;
|
|
typedef std::streamoff streamoff;
|
|
# 419 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
enum event
|
|
{
|
|
erase_event,
|
|
imbue_event,
|
|
copyfmt_event
|
|
};
|
|
# 436 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
|
|
# 448 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
void
|
|
register_callback(event_callback __fn, int __index);
|
|
|
|
protected:
|
|
streamsize _M_precision;
|
|
streamsize _M_width;
|
|
fmtflags _M_flags;
|
|
iostate _M_exception;
|
|
iostate _M_streambuf_state;
|
|
|
|
|
|
|
|
struct _Callback_list
|
|
{
|
|
|
|
_Callback_list* _M_next;
|
|
ios_base::event_callback _M_fn;
|
|
int _M_index;
|
|
_Atomic_word _M_refcount;
|
|
|
|
_Callback_list(ios_base::event_callback __fn, int __index,
|
|
_Callback_list* __cb)
|
|
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
|
|
|
|
void
|
|
_M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
|
|
|
|
|
|
int
|
|
_M_remove_reference()
|
|
{
|
|
|
|
;
|
|
int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
|
|
if (__res == 0)
|
|
{
|
|
;
|
|
}
|
|
return __res;
|
|
}
|
|
};
|
|
|
|
_Callback_list* _M_callbacks;
|
|
|
|
void
|
|
_M_call_callbacks(event __ev) throw();
|
|
|
|
void
|
|
_M_dispose_callbacks(void) throw();
|
|
|
|
|
|
struct _Words
|
|
{
|
|
void* _M_pword;
|
|
long _M_iword;
|
|
_Words() : _M_pword(0), _M_iword(0) { }
|
|
};
|
|
|
|
|
|
_Words _M_word_zero;
|
|
|
|
|
|
|
|
enum { _S_local_word_size = 8 };
|
|
_Words _M_local_word[_S_local_word_size];
|
|
|
|
|
|
int _M_word_size;
|
|
_Words* _M_word;
|
|
|
|
_Words&
|
|
_M_grow_words(int __index, bool __iword);
|
|
|
|
|
|
locale _M_ios_locale;
|
|
|
|
void
|
|
_M_init() throw();
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
class Init
|
|
{
|
|
friend class ios_base;
|
|
public:
|
|
Init();
|
|
~Init();
|
|
|
|
private:
|
|
static _Atomic_word _S_refcount;
|
|
static bool _S_synced_with_stdio;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fmtflags
|
|
flags() const
|
|
{ return _M_flags; }
|
|
# 561 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
fmtflags
|
|
flags(fmtflags __fmtfl)
|
|
{
|
|
fmtflags __old = _M_flags;
|
|
_M_flags = __fmtfl;
|
|
return __old;
|
|
}
|
|
# 577 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
fmtflags
|
|
setf(fmtflags __fmtfl)
|
|
{
|
|
fmtflags __old = _M_flags;
|
|
_M_flags |= __fmtfl;
|
|
return __old;
|
|
}
|
|
# 594 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
fmtflags
|
|
setf(fmtflags __fmtfl, fmtflags __mask)
|
|
{
|
|
fmtflags __old = _M_flags;
|
|
_M_flags &= ~__mask;
|
|
_M_flags |= (__fmtfl & __mask);
|
|
return __old;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
unsetf(fmtflags __mask)
|
|
{ _M_flags &= ~__mask; }
|
|
# 620 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
streamsize
|
|
precision() const
|
|
{ return _M_precision; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
streamsize
|
|
precision(streamsize __prec)
|
|
{
|
|
streamsize __old = _M_precision;
|
|
_M_precision = __prec;
|
|
return __old;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
streamsize
|
|
width() const
|
|
{ return _M_width; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
streamsize
|
|
width(streamsize __wide)
|
|
{
|
|
streamsize __old = _M_width;
|
|
_M_width = __wide;
|
|
return __old;
|
|
}
|
|
# 671 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
static bool
|
|
sync_with_stdio(bool __sync = true);
|
|
# 683 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
locale
|
|
imbue(const locale& __loc) throw();
|
|
# 694 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
locale
|
|
getloc() const
|
|
{ return _M_ios_locale; }
|
|
# 705 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
const locale&
|
|
_M_getloc() const
|
|
{ return _M_ios_locale; }
|
|
# 724 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
static int
|
|
xalloc() throw();
|
|
# 740 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
long&
|
|
iword(int __ix)
|
|
{
|
|
_Words& __word = (__ix < _M_word_size)
|
|
? _M_word[__ix] : _M_grow_words(__ix, true);
|
|
return __word._M_iword;
|
|
}
|
|
# 761 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
void*&
|
|
pword(int __ix)
|
|
{
|
|
_Words& __word = (__ix < _M_word_size)
|
|
? _M_word[__ix] : _M_grow_words(__ix, false);
|
|
return __word._M_pword;
|
|
}
|
|
# 778 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
|
|
virtual ~ios_base();
|
|
|
|
protected:
|
|
ios_base() throw ();
|
|
|
|
|
|
|
|
private:
|
|
ios_base(const ios_base&);
|
|
|
|
ios_base&
|
|
operator=(const ios_base&);
|
|
};
|
|
|
|
|
|
|
|
inline ios_base&
|
|
boolalpha(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::boolalpha);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
noboolalpha(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::boolalpha);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
showbase(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::showbase);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
noshowbase(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::showbase);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
showpoint(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::showpoint);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
noshowpoint(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::showpoint);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
showpos(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::showpos);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
noshowpos(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::showpos);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
skipws(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::skipws);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
noskipws(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::skipws);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
uppercase(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::uppercase);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
nouppercase(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::uppercase);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
unitbuf(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::unitbuf);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
nounitbuf(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::unitbuf);
|
|
return __base;
|
|
}
|
|
|
|
|
|
|
|
inline ios_base&
|
|
internal(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::internal, ios_base::adjustfield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
left(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::left, ios_base::adjustfield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
right(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::right, ios_base::adjustfield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
|
|
inline ios_base&
|
|
dec(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::dec, ios_base::basefield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
hex(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::hex, ios_base::basefield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
oct(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::oct, ios_base::basefield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
|
|
inline ios_base&
|
|
fixed(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::fixed, ios_base::floatfield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
inline ios_base&
|
|
scientific(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::scientific, ios_base::floatfield);
|
|
return __base;
|
|
}
|
|
|
|
|
|
}
|
|
# 43 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/streambuf" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/streambuf" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/streambuf" 3
|
|
# 45 "/usr/include/c++/4.8.2/streambuf" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
streamsize
|
|
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
|
|
basic_streambuf<_CharT, _Traits>*, bool&);
|
|
# 119 "/usr/include/c++/4.8.2/streambuf" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class basic_streambuf
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
|
|
|
|
|
|
friend class basic_ios<char_type, traits_type>;
|
|
friend class basic_istream<char_type, traits_type>;
|
|
friend class basic_ostream<char_type, traits_type>;
|
|
friend class istreambuf_iterator<char_type, traits_type>;
|
|
friend class ostreambuf_iterator<char_type, traits_type>;
|
|
|
|
friend streamsize
|
|
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
|
|
|
|
template<bool _IsMove, typename _CharT2>
|
|
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
|
|
_CharT2*>::__type
|
|
__copy_move_a2(istreambuf_iterator<_CharT2>,
|
|
istreambuf_iterator<_CharT2>, _CharT2*);
|
|
|
|
template<typename _CharT2>
|
|
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
|
|
istreambuf_iterator<_CharT2> >::__type
|
|
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
|
|
const _CharT2&);
|
|
|
|
template<typename _CharT2, typename _Traits2>
|
|
friend basic_istream<_CharT2, _Traits2>&
|
|
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
|
|
|
|
template<typename _CharT2, typename _Traits2, typename _Alloc>
|
|
friend basic_istream<_CharT2, _Traits2>&
|
|
operator>>(basic_istream<_CharT2, _Traits2>&,
|
|
basic_string<_CharT2, _Traits2, _Alloc>&);
|
|
|
|
template<typename _CharT2, typename _Traits2, typename _Alloc>
|
|
friend basic_istream<_CharT2, _Traits2>&
|
|
getline(basic_istream<_CharT2, _Traits2>&,
|
|
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
char_type* _M_in_beg;
|
|
char_type* _M_in_cur;
|
|
char_type* _M_in_end;
|
|
char_type* _M_out_beg;
|
|
char_type* _M_out_cur;
|
|
char_type* _M_out_end;
|
|
|
|
|
|
locale _M_buf_locale;
|
|
|
|
public:
|
|
|
|
virtual
|
|
~basic_streambuf()
|
|
{ }
|
|
# 208 "/usr/include/c++/4.8.2/streambuf" 3
|
|
locale
|
|
pubimbue(const locale& __loc)
|
|
{
|
|
locale __tmp(this->getloc());
|
|
this->imbue(__loc);
|
|
_M_buf_locale = __loc;
|
|
return __tmp;
|
|
}
|
|
# 225 "/usr/include/c++/4.8.2/streambuf" 3
|
|
locale
|
|
getloc() const
|
|
{ return _M_buf_locale; }
|
|
# 238 "/usr/include/c++/4.8.2/streambuf" 3
|
|
basic_streambuf*
|
|
pubsetbuf(char_type* __s, streamsize __n)
|
|
{ return this->setbuf(__s, __n); }
|
|
# 250 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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); }
|
|
# 262 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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(); }
|
|
# 283 "/usr/include/c++/4.8.2/streambuf" 3
|
|
streamsize
|
|
in_avail()
|
|
{
|
|
const streamsize __ret = this->egptr() - this->gptr();
|
|
return __ret ? __ret : this->showmanyc();
|
|
}
|
|
# 297 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 315 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 337 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 356 "/usr/include/c++/4.8.2/streambuf" 3
|
|
streamsize
|
|
sgetn(char_type* __s, streamsize __n)
|
|
{ return this->xsgetn(__s, __n); }
|
|
# 371 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 396 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 423 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 449 "/usr/include/c++/4.8.2/streambuf" 3
|
|
streamsize
|
|
sputn(const char_type* __s, streamsize __n)
|
|
{ return this->xsputn(__s, __n); }
|
|
|
|
protected:
|
|
# 463 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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())
|
|
{ }
|
|
# 481 "/usr/include/c++/4.8.2/streambuf" 3
|
|
char_type*
|
|
eback() const { return _M_in_beg; }
|
|
|
|
char_type*
|
|
gptr() const { return _M_in_cur; }
|
|
|
|
char_type*
|
|
egptr() const { return _M_in_end; }
|
|
# 497 "/usr/include/c++/4.8.2/streambuf" 3
|
|
void
|
|
gbump(int __n) { _M_in_cur += __n; }
|
|
# 508 "/usr/include/c++/4.8.2/streambuf" 3
|
|
void
|
|
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
|
|
{
|
|
_M_in_beg = __gbeg;
|
|
_M_in_cur = __gnext;
|
|
_M_in_end = __gend;
|
|
}
|
|
# 528 "/usr/include/c++/4.8.2/streambuf" 3
|
|
char_type*
|
|
pbase() const { return _M_out_beg; }
|
|
|
|
char_type*
|
|
pptr() const { return _M_out_cur; }
|
|
|
|
char_type*
|
|
epptr() const { return _M_out_end; }
|
|
# 544 "/usr/include/c++/4.8.2/streambuf" 3
|
|
void
|
|
pbump(int __n) { _M_out_cur += __n; }
|
|
# 554 "/usr/include/c++/4.8.2/streambuf" 3
|
|
void
|
|
setp(char_type* __pbeg, char_type* __pend)
|
|
{
|
|
_M_out_beg = _M_out_cur = __pbeg;
|
|
_M_out_end = __pend;
|
|
}
|
|
# 575 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual void
|
|
imbue(const locale& __loc)
|
|
{ }
|
|
# 590 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual basic_streambuf<char_type,_Traits>*
|
|
setbuf(char_type*, streamsize)
|
|
{ return this; }
|
|
# 601 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual pos_type
|
|
seekoff(off_type, ios_base::seekdir,
|
|
ios_base::openmode = ios_base::in | ios_base::out)
|
|
{ return pos_type(off_type(-1)); }
|
|
# 613 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual pos_type
|
|
seekpos(pos_type,
|
|
ios_base::openmode = ios_base::in | ios_base::out)
|
|
{ return pos_type(off_type(-1)); }
|
|
# 626 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual int
|
|
sync() { return 0; }
|
|
# 648 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual streamsize
|
|
showmanyc() { return 0; }
|
|
# 664 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual streamsize
|
|
xsgetn(char_type* __s, streamsize __n);
|
|
# 686 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual int_type
|
|
underflow()
|
|
{ return traits_type::eof(); }
|
|
# 699 "/usr/include/c++/4.8.2/streambuf" 3
|
|
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;
|
|
}
|
|
# 723 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual int_type
|
|
pbackfail(int_type __c = traits_type::eof())
|
|
{ return traits_type::eof(); }
|
|
# 741 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual streamsize
|
|
xsputn(const char_type* __s, streamsize __n);
|
|
# 767 "/usr/include/c++/4.8.2/streambuf" 3
|
|
virtual int_type
|
|
overflow(int_type __c = traits_type::eof())
|
|
{ return traits_type::eof(); }
|
|
|
|
|
|
|
|
public:
|
|
# 782 "/usr/include/c++/4.8.2/streambuf" 3
|
|
void
|
|
stossc()
|
|
{
|
|
if (this->gptr() < this->egptr())
|
|
this->gbump(1);
|
|
else
|
|
this->uflow();
|
|
}
|
|
|
|
|
|
|
|
void
|
|
__safe_gbump(streamsize __n) { _M_in_cur += __n; }
|
|
|
|
void
|
|
__safe_pbump(streamsize __n) { _M_out_cur += __n; }
|
|
|
|
private:
|
|
|
|
|
|
basic_streambuf(const basic_streambuf& __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_end),
|
|
_M_buf_locale(__sb._M_buf_locale)
|
|
{ }
|
|
|
|
basic_streambuf&
|
|
operator=(const basic_streambuf& __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_end;
|
|
_M_buf_locale = __sb._M_buf_locale;
|
|
return *this;
|
|
};
|
|
};
|
|
|
|
|
|
template<>
|
|
streamsize
|
|
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
|
|
basic_streambuf<char>* __sbout, bool& __ineof);
|
|
|
|
template<>
|
|
streamsize
|
|
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
|
|
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
|
|
|
|
|
|
|
|
}
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
streamsize
|
|
basic_streambuf<_CharT, _Traits>::
|
|
xsgetn(char_type* __s, streamsize __n)
|
|
{
|
|
streamsize __ret = 0;
|
|
while (__ret < __n)
|
|
{
|
|
const streamsize __buf_len = this->egptr() - this->gptr();
|
|
if (__buf_len)
|
|
{
|
|
const streamsize __remaining = __n - __ret;
|
|
const streamsize __len = std::min(__buf_len, __remaining);
|
|
traits_type::copy(__s, this->gptr(), __len);
|
|
__ret += __len;
|
|
__s += __len;
|
|
this->__safe_gbump(__len);
|
|
}
|
|
|
|
if (__ret < __n)
|
|
{
|
|
const int_type __c = this->uflow();
|
|
if (!traits_type::eq_int_type(__c, traits_type::eof()))
|
|
{
|
|
traits_type::assign(*__s++, traits_type::to_char_type(__c));
|
|
++__ret;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
streamsize
|
|
basic_streambuf<_CharT, _Traits>::
|
|
xsputn(const char_type* __s, streamsize __n)
|
|
{
|
|
streamsize __ret = 0;
|
|
while (__ret < __n)
|
|
{
|
|
const streamsize __buf_len = this->epptr() - this->pptr();
|
|
if (__buf_len)
|
|
{
|
|
const streamsize __remaining = __n - __ret;
|
|
const streamsize __len = std::min(__buf_len, __remaining);
|
|
traits_type::copy(this->pptr(), __s, __len);
|
|
__ret += __len;
|
|
__s += __len;
|
|
this->__safe_pbump(__len);
|
|
}
|
|
|
|
if (__ret < __n)
|
|
{
|
|
int_type __c = this->overflow(traits_type::to_int_type(*__s));
|
|
if (!traits_type::eq_int_type(__c, traits_type::eof()))
|
|
{
|
|
++__ret;
|
|
++__s;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
streamsize
|
|
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
|
|
basic_streambuf<_CharT, _Traits>* __sbout,
|
|
bool& __ineof)
|
|
{
|
|
streamsize __ret = 0;
|
|
__ineof = true;
|
|
typename _Traits::int_type __c = __sbin->sgetc();
|
|
while (!_Traits::eq_int_type(__c, _Traits::eof()))
|
|
{
|
|
__c = __sbout->sputc(_Traits::to_char_type(__c));
|
|
if (_Traits::eq_int_type(__c, _Traits::eof()))
|
|
{
|
|
__ineof = false;
|
|
break;
|
|
}
|
|
++__ret;
|
|
__c = __sbin->snextc();
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline streamsize
|
|
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
|
|
basic_streambuf<_CharT, _Traits>* __sbout)
|
|
{
|
|
bool __ineof;
|
|
return __copy_streambufs_eof(__sbin, __sbout, __ineof);
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class basic_streambuf<char>;
|
|
extern template
|
|
streamsize
|
|
__copy_streambufs(basic_streambuf<char>*,
|
|
basic_streambuf<char>*);
|
|
extern template
|
|
streamsize
|
|
__copy_streambufs_eof(basic_streambuf<char>*,
|
|
basic_streambuf<char>*, bool&);
|
|
|
|
|
|
extern template class basic_streambuf<wchar_t>;
|
|
extern template
|
|
streamsize
|
|
__copy_streambufs(basic_streambuf<wchar_t>*,
|
|
basic_streambuf<wchar_t>*);
|
|
extern template
|
|
streamsize
|
|
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
|
|
basic_streambuf<wchar_t>*, bool&);
|
|
|
|
|
|
|
|
|
|
}
|
|
# 839 "/usr/include/c++/4.8.2/streambuf" 2 3
|
|
# 44 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/basic_ios.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/locale_facets.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/cwctype" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/cwctype" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/cwctype" 3
|
|
# 50 "/usr/include/c++/4.8.2/cwctype" 3
|
|
# 1 "/usr/include/wctype.h" 1 3 4
|
|
# 33 "/usr/include/wctype.h" 3 4
|
|
# 1 "/usr/include/wchar.h" 1 3 4
|
|
# 34 "/usr/include/wctype.h" 2 3 4
|
|
# 49 "/usr/include/wctype.h" 3 4
|
|
|
|
|
|
|
|
typedef unsigned long int wctype_t;
|
|
|
|
# 71 "/usr/include/wctype.h" 3 4
|
|
enum
|
|
{
|
|
__ISwupper = 0,
|
|
__ISwlower = 1,
|
|
__ISwalpha = 2,
|
|
__ISwdigit = 3,
|
|
__ISwxdigit = 4,
|
|
__ISwspace = 5,
|
|
__ISwprint = 6,
|
|
__ISwgraph = 7,
|
|
__ISwblank = 8,
|
|
__ISwcntrl = 9,
|
|
__ISwpunct = 10,
|
|
__ISwalnum = 11,
|
|
|
|
_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
|
|
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
|
|
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
|
|
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
|
|
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
|
|
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
|
|
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
|
|
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
|
|
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
|
|
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
|
|
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
|
|
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
|
|
};
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int iswalnum (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int iswalpha (wint_t __wc) throw ();
|
|
|
|
|
|
extern int iswcntrl (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
extern int iswdigit (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
extern int iswgraph (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswlower (wint_t __wc) throw ();
|
|
|
|
|
|
extern int iswprint (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswpunct (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswspace (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswupper (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswxdigit (wint_t __wc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int iswblank (wint_t __wc) throw ();
|
|
# 171 "/usr/include/wctype.h" 3 4
|
|
extern wctype_t wctype (const char *__property) throw ();
|
|
|
|
|
|
|
|
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef const __int32_t *wctrans_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t towlower (wint_t __wc) throw ();
|
|
|
|
|
|
extern wint_t towupper (wint_t __wc) throw ();
|
|
|
|
|
|
}
|
|
# 213 "/usr/include/wctype.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
extern wctrans_t wctrans (const char *__property) throw ();
|
|
|
|
|
|
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
|
|
extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
extern wctype_t wctype_l (const char *__property, __locale_t __locale)
|
|
throw ();
|
|
|
|
|
|
|
|
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
|
|
|
|
|
|
|
|
extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
|
|
throw ();
|
|
|
|
|
|
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
|
|
__locale_t __locale) throw ();
|
|
|
|
|
|
|
|
}
|
|
# 51 "/usr/include/c++/4.8.2/cwctype" 2 3
|
|
# 80 "/usr/include/c++/4.8.2/cwctype" 3
|
|
namespace std
|
|
{
|
|
using ::wctrans_t;
|
|
using ::wctype_t;
|
|
using ::wint_t;
|
|
|
|
using ::iswalnum;
|
|
using ::iswalpha;
|
|
|
|
using ::iswblank;
|
|
|
|
using ::iswcntrl;
|
|
using ::iswctype;
|
|
using ::iswdigit;
|
|
using ::iswgraph;
|
|
using ::iswlower;
|
|
using ::iswprint;
|
|
using ::iswpunct;
|
|
using ::iswspace;
|
|
using ::iswupper;
|
|
using ::iswxdigit;
|
|
using ::towctrans;
|
|
using ::towlower;
|
|
using ::towupper;
|
|
using ::wctrans;
|
|
using ::wctype;
|
|
}
|
|
# 40 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/cctype" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/cctype" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/cctype" 3
|
|
# 41 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_base.h" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_base.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
struct ctype_base
|
|
{
|
|
|
|
typedef const int* __to_type;
|
|
|
|
|
|
|
|
typedef unsigned short mask;
|
|
static const mask upper = _ISupper;
|
|
static const mask lower = _ISlower;
|
|
static const mask alpha = _ISalpha;
|
|
static const mask digit = _ISdigit;
|
|
static const mask xdigit = _ISxdigit;
|
|
static const mask space = _ISspace;
|
|
static const mask print = _ISprint;
|
|
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
|
|
static const mask cntrl = _IScntrl;
|
|
static const mask punct = _ISpunct;
|
|
static const mask alnum = _ISalpha | _ISdigit;
|
|
};
|
|
|
|
|
|
}
|
|
# 42 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 49 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class istreambuf_iterator
|
|
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
|
|
_CharT*,
|
|
|
|
|
|
|
|
|
|
_CharT&>
|
|
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef _Traits traits_type;
|
|
typedef typename _Traits::int_type int_type;
|
|
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
|
|
typedef basic_istream<_CharT, _Traits> istream_type;
|
|
|
|
|
|
template<typename _CharT2>
|
|
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
|
|
ostreambuf_iterator<_CharT2> >::__type
|
|
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
|
|
ostreambuf_iterator<_CharT2>);
|
|
|
|
template<bool _IsMove, typename _CharT2>
|
|
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
|
|
_CharT2*>::__type
|
|
__copy_move_a2(istreambuf_iterator<_CharT2>,
|
|
istreambuf_iterator<_CharT2>, _CharT2*);
|
|
|
|
template<typename _CharT2>
|
|
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
|
|
istreambuf_iterator<_CharT2> >::__type
|
|
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
|
|
const _CharT2&);
|
|
|
|
private:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
mutable streambuf_type* _M_sbuf;
|
|
mutable int_type _M_c;
|
|
|
|
public:
|
|
|
|
istreambuf_iterator() throw()
|
|
: _M_sbuf(0), _M_c(traits_type::eof()) { }
|
|
# 112 "/usr/include/c++/4.8.2/bits/streambuf_iterator.h" 3
|
|
istreambuf_iterator(istream_type& __s) throw()
|
|
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
|
|
|
|
|
|
istreambuf_iterator(streambuf_type* __s) throw()
|
|
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
|
|
|
|
|
|
|
|
|
|
char_type
|
|
operator*() const
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return traits_type::to_char_type(_M_get());
|
|
}
|
|
|
|
|
|
istreambuf_iterator&
|
|
operator++()
|
|
{
|
|
|
|
|
|
;
|
|
if (_M_sbuf)
|
|
{
|
|
_M_sbuf->sbumpc();
|
|
_M_c = traits_type::eof();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
istreambuf_iterator
|
|
operator++(int)
|
|
{
|
|
|
|
|
|
;
|
|
|
|
istreambuf_iterator __old = *this;
|
|
if (_M_sbuf)
|
|
{
|
|
__old._M_c = _M_sbuf->sbumpc();
|
|
_M_c = traits_type::eof();
|
|
}
|
|
return __old;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
equal(const istreambuf_iterator& __b) const
|
|
{ return _M_at_eof() == __b._M_at_eof(); }
|
|
|
|
private:
|
|
int_type
|
|
_M_get() const
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
int_type __ret = __eof;
|
|
if (_M_sbuf)
|
|
{
|
|
if (!traits_type::eq_int_type(_M_c, __eof))
|
|
__ret = _M_c;
|
|
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
|
|
__eof))
|
|
_M_c = __ret;
|
|
else
|
|
_M_sbuf = 0;
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
bool
|
|
_M_at_eof() const
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
return traits_type::eq_int_type(_M_get(), __eof);
|
|
}
|
|
};
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline bool
|
|
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
|
|
const istreambuf_iterator<_CharT, _Traits>& __b)
|
|
{ return __a.equal(__b); }
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline bool
|
|
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
|
|
const istreambuf_iterator<_CharT, _Traits>& __b)
|
|
{ return !__a.equal(__b); }
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
class ostreambuf_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void>
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef _Traits traits_type;
|
|
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
|
|
typedef basic_ostream<_CharT, _Traits> ostream_type;
|
|
|
|
|
|
template<typename _CharT2>
|
|
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
|
|
ostreambuf_iterator<_CharT2> >::__type
|
|
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
|
|
ostreambuf_iterator<_CharT2>);
|
|
|
|
private:
|
|
streambuf_type* _M_sbuf;
|
|
bool _M_failed;
|
|
|
|
public:
|
|
|
|
ostreambuf_iterator(ostream_type& __s) throw()
|
|
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
|
|
|
|
|
|
ostreambuf_iterator(streambuf_type* __s) throw()
|
|
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
|
|
|
|
|
|
ostreambuf_iterator&
|
|
operator=(_CharT __c)
|
|
{
|
|
if (!_M_failed &&
|
|
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
|
|
_M_failed = true;
|
|
return *this;
|
|
}
|
|
|
|
|
|
ostreambuf_iterator&
|
|
operator*()
|
|
{ return *this; }
|
|
|
|
|
|
ostreambuf_iterator&
|
|
operator++(int)
|
|
{ return *this; }
|
|
|
|
|
|
ostreambuf_iterator&
|
|
operator++()
|
|
{ return *this; }
|
|
|
|
|
|
bool
|
|
failed() const throw()
|
|
{ return _M_failed; }
|
|
|
|
ostreambuf_iterator&
|
|
_M_put(const _CharT* __ws, streamsize __len)
|
|
{
|
|
if (__builtin_expect(!_M_failed, true)
|
|
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
|
|
false))
|
|
_M_failed = true;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
|
|
template<typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
ostreambuf_iterator<_CharT> >::__type
|
|
copy(istreambuf_iterator<_CharT> __first,
|
|
istreambuf_iterator<_CharT> __last,
|
|
ostreambuf_iterator<_CharT> __result)
|
|
{
|
|
if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
|
|
{
|
|
bool __ineof;
|
|
__copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
|
|
if (!__ineof)
|
|
__result._M_failed = true;
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
template<bool _IsMove, typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
ostreambuf_iterator<_CharT> >::__type
|
|
__copy_move_a2(_CharT* __first, _CharT* __last,
|
|
ostreambuf_iterator<_CharT> __result)
|
|
{
|
|
const streamsize __num = __last - __first;
|
|
if (__num > 0)
|
|
__result._M_put(__first, __num);
|
|
return __result;
|
|
}
|
|
|
|
template<bool _IsMove, typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
ostreambuf_iterator<_CharT> >::__type
|
|
__copy_move_a2(const _CharT* __first, const _CharT* __last,
|
|
ostreambuf_iterator<_CharT> __result)
|
|
{
|
|
const streamsize __num = __last - __first;
|
|
if (__num > 0)
|
|
__result._M_put(__first, __num);
|
|
return __result;
|
|
}
|
|
|
|
template<bool _IsMove, typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
_CharT*>::__type
|
|
__copy_move_a2(istreambuf_iterator<_CharT> __first,
|
|
istreambuf_iterator<_CharT> __last, _CharT* __result)
|
|
{
|
|
typedef istreambuf_iterator<_CharT> __is_iterator_type;
|
|
typedef typename __is_iterator_type::traits_type traits_type;
|
|
typedef typename __is_iterator_type::streambuf_type streambuf_type;
|
|
typedef typename traits_type::int_type int_type;
|
|
|
|
if (__first._M_sbuf && !__last._M_sbuf)
|
|
{
|
|
streambuf_type* __sb = __first._M_sbuf;
|
|
int_type __c = __sb->sgetc();
|
|
while (!traits_type::eq_int_type(__c, traits_type::eof()))
|
|
{
|
|
const streamsize __n = __sb->egptr() - __sb->gptr();
|
|
if (__n > 1)
|
|
{
|
|
traits_type::copy(__result, __sb->gptr(), __n);
|
|
__sb->__safe_gbump(__n);
|
|
__result += __n;
|
|
__c = __sb->underflow();
|
|
}
|
|
else
|
|
{
|
|
*__result++ = traits_type::to_char_type(__c);
|
|
__c = __sb->snextc();
|
|
}
|
|
}
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
template<typename _CharT>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
|
|
istreambuf_iterator<_CharT> >::__type
|
|
find(istreambuf_iterator<_CharT> __first,
|
|
istreambuf_iterator<_CharT> __last, const _CharT& __val)
|
|
{
|
|
typedef istreambuf_iterator<_CharT> __is_iterator_type;
|
|
typedef typename __is_iterator_type::traits_type traits_type;
|
|
typedef typename __is_iterator_type::streambuf_type streambuf_type;
|
|
typedef typename traits_type::int_type int_type;
|
|
|
|
if (__first._M_sbuf && !__last._M_sbuf)
|
|
{
|
|
const int_type __ival = traits_type::to_int_type(__val);
|
|
streambuf_type* __sb = __first._M_sbuf;
|
|
int_type __c = __sb->sgetc();
|
|
while (!traits_type::eq_int_type(__c, traits_type::eof())
|
|
&& !traits_type::eq_int_type(__c, __ival))
|
|
{
|
|
streamsize __n = __sb->egptr() - __sb->gptr();
|
|
if (__n > 1)
|
|
{
|
|
const _CharT* __p = traits_type::find(__sb->gptr(),
|
|
__n, __val);
|
|
if (__p)
|
|
__n = __p - __sb->gptr();
|
|
__sb->__safe_gbump(__n);
|
|
__c = __sb->sgetc();
|
|
}
|
|
else
|
|
__c = __sb->snextc();
|
|
}
|
|
|
|
if (!traits_type::eq_int_type(__c, traits_type::eof()))
|
|
__first._M_c = __c;
|
|
else
|
|
__first._M_sbuf = 0;
|
|
}
|
|
return __first;
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
# 49 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 64 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<typename _Tp>
|
|
void
|
|
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
|
|
const __c_locale&) throw();
|
|
|
|
|
|
template<>
|
|
void
|
|
__convert_to_v(const char*, float&, ios_base::iostate&,
|
|
const __c_locale&) throw();
|
|
|
|
template<>
|
|
void
|
|
__convert_to_v(const char*, double&, ios_base::iostate&,
|
|
const __c_locale&) throw();
|
|
|
|
template<>
|
|
void
|
|
__convert_to_v(const char*, long double&, ios_base::iostate&,
|
|
const __c_locale&) throw();
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
struct __pad
|
|
{
|
|
static void
|
|
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
|
|
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
_CharT*
|
|
__add_grouping(_CharT* __s, _CharT __sep,
|
|
const char* __gbeg, size_t __gsize,
|
|
const _CharT* __first, const _CharT* __last);
|
|
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
inline
|
|
ostreambuf_iterator<_CharT>
|
|
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
|
|
{
|
|
__s._M_put(__ws, __len);
|
|
return __s;
|
|
}
|
|
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
inline
|
|
_OutIter
|
|
__write(_OutIter __s, const _CharT* __ws, int __len)
|
|
{
|
|
for (int __j = 0; __j < __len; __j++, ++__s)
|
|
*__s = __ws[__j];
|
|
return __s;
|
|
}
|
|
# 142 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<typename _CharT>
|
|
class __ctype_abstract_base : public locale::facet, public ctype_base
|
|
{
|
|
public:
|
|
|
|
|
|
typedef _CharT char_type;
|
|
# 161 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
bool
|
|
is(mask __m, char_type __c) const
|
|
{ return this->do_is(__m, __c); }
|
|
# 178 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
|
|
{ return this->do_is(__lo, __hi, __vec); }
|
|
# 194 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
|
|
{ return this->do_scan_is(__m, __lo, __hi); }
|
|
# 210 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
|
|
{ return this->do_scan_not(__m, __lo, __hi); }
|
|
# 224 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
toupper(char_type __c) const
|
|
{ return this->do_toupper(__c); }
|
|
# 239 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
toupper(char_type *__lo, const char_type* __hi) const
|
|
{ return this->do_toupper(__lo, __hi); }
|
|
# 253 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
tolower(char_type __c) const
|
|
{ return this->do_tolower(__c); }
|
|
# 268 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
tolower(char_type* __lo, const char_type* __hi) const
|
|
{ return this->do_tolower(__lo, __hi); }
|
|
# 285 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
widen(char __c) const
|
|
{ return this->do_widen(__c); }
|
|
# 304 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char*
|
|
widen(const char* __lo, const char* __hi, char_type* __to) const
|
|
{ return this->do_widen(__lo, __hi, __to); }
|
|
# 323 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char
|
|
narrow(char_type __c, char __dfault) const
|
|
{ return this->do_narrow(__c, __dfault); }
|
|
# 345 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
narrow(const char_type* __lo, const char_type* __hi,
|
|
char __dfault, char* __to) const
|
|
{ return this->do_narrow(__lo, __hi, __dfault, __to); }
|
|
|
|
protected:
|
|
explicit
|
|
__ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
|
|
|
|
virtual
|
|
~__ctype_abstract_base() { }
|
|
# 370 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual bool
|
|
do_is(mask __m, char_type __c) const = 0;
|
|
# 389 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_is(const char_type* __lo, const char_type* __hi,
|
|
mask* __vec) const = 0;
|
|
# 408 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_scan_is(mask __m, const char_type* __lo,
|
|
const char_type* __hi) const = 0;
|
|
# 427 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_scan_not(mask __m, const char_type* __lo,
|
|
const char_type* __hi) const = 0;
|
|
# 445 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_toupper(char_type __c) const = 0;
|
|
# 462 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
|
|
# 478 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_tolower(char_type __c) const = 0;
|
|
# 495 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
|
|
# 514 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_widen(char __c) const = 0;
|
|
# 535 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char*
|
|
do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
|
|
# 556 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char
|
|
do_narrow(char_type __c, char __dfault) const = 0;
|
|
# 581 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_narrow(const char_type* __lo, const char_type* __hi,
|
|
char __dfault, char* __to) const = 0;
|
|
};
|
|
# 604 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<typename _CharT>
|
|
class ctype : public __ctype_abstract_base<_CharT>
|
|
{
|
|
public:
|
|
|
|
typedef _CharT char_type;
|
|
typedef typename __ctype_abstract_base<_CharT>::mask mask;
|
|
|
|
|
|
static locale::id id;
|
|
|
|
explicit
|
|
ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
|
|
|
|
protected:
|
|
virtual
|
|
~ctype();
|
|
|
|
virtual bool
|
|
do_is(mask __m, char_type __c) const;
|
|
|
|
virtual const char_type*
|
|
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
|
|
|
|
virtual const char_type*
|
|
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
|
|
|
|
virtual const char_type*
|
|
do_scan_not(mask __m, const char_type* __lo,
|
|
const char_type* __hi) const;
|
|
|
|
virtual char_type
|
|
do_toupper(char_type __c) const;
|
|
|
|
virtual const char_type*
|
|
do_toupper(char_type* __lo, const char_type* __hi) const;
|
|
|
|
virtual char_type
|
|
do_tolower(char_type __c) const;
|
|
|
|
virtual const char_type*
|
|
do_tolower(char_type* __lo, const char_type* __hi) const;
|
|
|
|
virtual char_type
|
|
do_widen(char __c) const;
|
|
|
|
virtual const char*
|
|
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
|
|
|
|
virtual char
|
|
do_narrow(char_type, char __dfault) const;
|
|
|
|
virtual const char_type*
|
|
do_narrow(const char_type* __lo, const char_type* __hi,
|
|
char __dfault, char* __to) const;
|
|
};
|
|
|
|
template<typename _CharT>
|
|
locale::id ctype<_CharT>::id;
|
|
# 673 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<>
|
|
class ctype<char> : public locale::facet, public ctype_base
|
|
{
|
|
public:
|
|
|
|
|
|
typedef char char_type;
|
|
|
|
protected:
|
|
|
|
__c_locale _M_c_locale_ctype;
|
|
bool _M_del;
|
|
__to_type _M_toupper;
|
|
__to_type _M_tolower;
|
|
const mask* _M_table;
|
|
mutable char _M_widen_ok;
|
|
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
|
|
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
|
|
mutable char _M_narrow_ok;
|
|
|
|
|
|
public:
|
|
|
|
static locale::id id;
|
|
|
|
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
|
|
# 710 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
|
|
# 723 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
|
|
size_t __refs = 0);
|
|
# 736 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
inline bool
|
|
is(mask __m, char __c) const;
|
|
# 751 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
inline const char*
|
|
is(const char* __lo, const char* __hi, mask* __vec) const;
|
|
# 765 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
inline const char*
|
|
scan_is(mask __m, const char* __lo, const char* __hi) const;
|
|
# 779 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
inline const char*
|
|
scan_not(mask __m, const char* __lo, const char* __hi) const;
|
|
# 794 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
toupper(char_type __c) const
|
|
{ return this->do_toupper(__c); }
|
|
# 811 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
toupper(char_type *__lo, const char_type* __hi) const
|
|
{ return this->do_toupper(__lo, __hi); }
|
|
# 827 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
tolower(char_type __c) const
|
|
{ return this->do_tolower(__c); }
|
|
# 844 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
tolower(char_type* __lo, const char_type* __hi) const
|
|
{ return this->do_tolower(__lo, __hi); }
|
|
# 864 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
widen(char __c) const
|
|
{
|
|
if (_M_widen_ok)
|
|
return _M_widen[static_cast<unsigned char>(__c)];
|
|
this->_M_widen_init();
|
|
return this->do_widen(__c);
|
|
}
|
|
# 891 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char*
|
|
widen(const char* __lo, const char* __hi, char_type* __to) const
|
|
{
|
|
if (_M_widen_ok == 1)
|
|
{
|
|
__builtin_memcpy(__to, __lo, __hi - __lo);
|
|
return __hi;
|
|
}
|
|
if (!_M_widen_ok)
|
|
_M_widen_init();
|
|
return this->do_widen(__lo, __hi, __to);
|
|
}
|
|
# 922 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char
|
|
narrow(char_type __c, char __dfault) const
|
|
{
|
|
if (_M_narrow[static_cast<unsigned char>(__c)])
|
|
return _M_narrow[static_cast<unsigned char>(__c)];
|
|
const char __t = do_narrow(__c, __dfault);
|
|
if (__t != __dfault)
|
|
_M_narrow[static_cast<unsigned char>(__c)] = __t;
|
|
return __t;
|
|
}
|
|
# 955 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
const char_type*
|
|
narrow(const char_type* __lo, const char_type* __hi,
|
|
char __dfault, char* __to) const
|
|
{
|
|
if (__builtin_expect(_M_narrow_ok == 1, true))
|
|
{
|
|
__builtin_memcpy(__to, __lo, __hi - __lo);
|
|
return __hi;
|
|
}
|
|
if (!_M_narrow_ok)
|
|
_M_narrow_init();
|
|
return this->do_narrow(__lo, __hi, __dfault, __to);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const mask*
|
|
table() const throw()
|
|
{ return _M_table; }
|
|
|
|
|
|
static const mask*
|
|
classic_table() throw();
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual
|
|
~ctype();
|
|
# 1004 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_toupper(char_type __c) const;
|
|
# 1021 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_toupper(char_type* __lo, const char_type* __hi) const;
|
|
# 1037 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_tolower(char_type __c) const;
|
|
# 1054 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_tolower(char_type* __lo, const char_type* __hi) const;
|
|
# 1074 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_widen(char __c) const
|
|
{ return __c; }
|
|
# 1097 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char*
|
|
do_widen(const char* __lo, const char* __hi, char_type* __to) const
|
|
{
|
|
__builtin_memcpy(__to, __lo, __hi - __lo);
|
|
return __hi;
|
|
}
|
|
# 1123 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char
|
|
do_narrow(char_type __c, char __dfault) const
|
|
{ return __c; }
|
|
# 1149 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_narrow(const char_type* __lo, const char_type* __hi,
|
|
char __dfault, char* __to) const
|
|
{
|
|
__builtin_memcpy(__to, __lo, __hi - __lo);
|
|
return __hi;
|
|
}
|
|
|
|
private:
|
|
void _M_narrow_init() const;
|
|
void _M_widen_init() const;
|
|
};
|
|
# 1174 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<>
|
|
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
|
|
{
|
|
public:
|
|
|
|
|
|
typedef wchar_t char_type;
|
|
typedef wctype_t __wmask_type;
|
|
|
|
protected:
|
|
__c_locale _M_c_locale_ctype;
|
|
|
|
|
|
bool _M_narrow_ok;
|
|
char _M_narrow[128];
|
|
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
|
|
|
|
|
|
mask _M_bit[16];
|
|
__wmask_type _M_wmask[16];
|
|
|
|
public:
|
|
|
|
|
|
static locale::id id;
|
|
# 1207 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
ctype(size_t __refs = 0);
|
|
# 1218 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
ctype(__c_locale __cloc, size_t __refs = 0);
|
|
|
|
protected:
|
|
__wmask_type
|
|
_M_convert_to_wmask(const mask __m) const throw();
|
|
|
|
|
|
virtual
|
|
~ctype();
|
|
# 1242 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual bool
|
|
do_is(mask __m, char_type __c) const;
|
|
# 1261 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
|
|
# 1279 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
|
|
# 1297 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_scan_not(mask __m, const char_type* __lo,
|
|
const char_type* __hi) const;
|
|
# 1314 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_toupper(char_type __c) const;
|
|
# 1331 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_toupper(char_type* __lo, const char_type* __hi) const;
|
|
# 1347 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_tolower(char_type __c) const;
|
|
# 1364 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_tolower(char_type* __lo, const char_type* __hi) const;
|
|
# 1384 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_widen(char __c) const;
|
|
# 1406 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char*
|
|
do_widen(const char* __lo, const char* __hi, char_type* __to) const;
|
|
# 1429 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char
|
|
do_narrow(char_type __c, char __dfault) const;
|
|
# 1455 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual const char_type*
|
|
do_narrow(const char_type* __lo, const char_type* __hi,
|
|
char __dfault, char* __to) const;
|
|
|
|
|
|
void
|
|
_M_initialize_ctype() throw();
|
|
};
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
class ctype_byname : public ctype<_CharT>
|
|
{
|
|
public:
|
|
typedef typename ctype<_CharT>::mask mask;
|
|
|
|
explicit
|
|
ctype_byname(const char* __s, size_t __refs = 0);
|
|
|
|
protected:
|
|
virtual
|
|
~ctype_byname() { };
|
|
};
|
|
|
|
|
|
template<>
|
|
class ctype_byname<char> : public ctype<char>
|
|
{
|
|
public:
|
|
explicit
|
|
ctype_byname(const char* __s, size_t __refs = 0);
|
|
|
|
protected:
|
|
virtual
|
|
~ctype_byname();
|
|
};
|
|
|
|
|
|
template<>
|
|
class ctype_byname<wchar_t> : public ctype<wchar_t>
|
|
{
|
|
public:
|
|
explicit
|
|
ctype_byname(const char* __s, size_t __refs = 0);
|
|
|
|
protected:
|
|
virtual
|
|
~ctype_byname();
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_inline.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
bool
|
|
ctype<char>::
|
|
is(mask __m, char __c) const
|
|
{ return _M_table[static_cast<unsigned char>(__c)] & __m; }
|
|
|
|
const char*
|
|
ctype<char>::
|
|
is(const char* __low, const char* __high, mask* __vec) const
|
|
{
|
|
while (__low < __high)
|
|
*__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
|
|
return __high;
|
|
}
|
|
|
|
const char*
|
|
ctype<char>::
|
|
scan_is(mask __m, const char* __low, const char* __high) const
|
|
{
|
|
while (__low < __high
|
|
&& !(_M_table[static_cast<unsigned char>(*__low)] & __m))
|
|
++__low;
|
|
return __low;
|
|
}
|
|
|
|
const char*
|
|
ctype<char>::
|
|
scan_not(mask __m, const char* __low, const char* __high) const
|
|
{
|
|
while (__low < __high
|
|
&& (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
|
|
++__low;
|
|
return __low;
|
|
}
|
|
|
|
|
|
}
|
|
# 1512 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
class __num_base
|
|
{
|
|
public:
|
|
|
|
|
|
enum
|
|
{
|
|
_S_ominus,
|
|
_S_oplus,
|
|
_S_ox,
|
|
_S_oX,
|
|
_S_odigits,
|
|
_S_odigits_end = _S_odigits + 16,
|
|
_S_oudigits = _S_odigits_end,
|
|
_S_oudigits_end = _S_oudigits + 16,
|
|
_S_oe = _S_odigits + 14,
|
|
_S_oE = _S_oudigits + 14,
|
|
_S_oend = _S_oudigits_end
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static const char* _S_atoms_out;
|
|
|
|
|
|
|
|
static const char* _S_atoms_in;
|
|
|
|
enum
|
|
{
|
|
_S_iminus,
|
|
_S_iplus,
|
|
_S_ix,
|
|
_S_iX,
|
|
_S_izero,
|
|
_S_ie = _S_izero + 14,
|
|
_S_iE = _S_izero + 20,
|
|
_S_iend = 26
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
|
|
};
|
|
|
|
template<typename _CharT>
|
|
struct __numpunct_cache : public locale::facet
|
|
{
|
|
const char* _M_grouping;
|
|
size_t _M_grouping_size;
|
|
bool _M_use_grouping;
|
|
const _CharT* _M_truename;
|
|
size_t _M_truename_size;
|
|
const _CharT* _M_falsename;
|
|
size_t _M_falsename_size;
|
|
_CharT _M_decimal_point;
|
|
_CharT _M_thousands_sep;
|
|
|
|
|
|
|
|
|
|
|
|
_CharT _M_atoms_out[__num_base::_S_oend];
|
|
|
|
|
|
|
|
|
|
|
|
_CharT _M_atoms_in[__num_base::_S_iend];
|
|
|
|
bool _M_allocated;
|
|
|
|
__numpunct_cache(size_t __refs = 0)
|
|
: facet(__refs), _M_grouping(0), _M_grouping_size(0),
|
|
_M_use_grouping(false),
|
|
_M_truename(0), _M_truename_size(0), _M_falsename(0),
|
|
_M_falsename_size(0), _M_decimal_point(_CharT()),
|
|
_M_thousands_sep(_CharT()), _M_allocated(false)
|
|
{ }
|
|
|
|
~__numpunct_cache();
|
|
|
|
void
|
|
_M_cache(const locale& __loc);
|
|
|
|
private:
|
|
__numpunct_cache&
|
|
operator=(const __numpunct_cache&);
|
|
|
|
explicit
|
|
__numpunct_cache(const __numpunct_cache&);
|
|
};
|
|
|
|
template<typename _CharT>
|
|
__numpunct_cache<_CharT>::~__numpunct_cache()
|
|
{
|
|
if (_M_allocated)
|
|
{
|
|
delete [] _M_grouping;
|
|
delete [] _M_truename;
|
|
delete [] _M_falsename;
|
|
}
|
|
}
|
|
# 1640 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<typename _CharT>
|
|
class numpunct : public locale::facet
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef basic_string<_CharT> string_type;
|
|
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
|
|
protected:
|
|
__cache_type* _M_data;
|
|
|
|
public:
|
|
|
|
static locale::id id;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
numpunct(size_t __refs = 0)
|
|
: facet(__refs), _M_data(0)
|
|
{ _M_initialize_numpunct(); }
|
|
# 1678 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
numpunct(__cache_type* __cache, size_t __refs = 0)
|
|
: facet(__refs), _M_data(__cache)
|
|
{ _M_initialize_numpunct(); }
|
|
# 1692 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
numpunct(__c_locale __cloc, size_t __refs = 0)
|
|
: facet(__refs), _M_data(0)
|
|
{ _M_initialize_numpunct(__cloc); }
|
|
# 1706 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
decimal_point() const
|
|
{ return this->do_decimal_point(); }
|
|
# 1719 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
char_type
|
|
thousands_sep() const
|
|
{ return this->do_thousands_sep(); }
|
|
# 1750 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
string
|
|
grouping() const
|
|
{ return this->do_grouping(); }
|
|
# 1763 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
string_type
|
|
truename() const
|
|
{ return this->do_truename(); }
|
|
# 1776 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
string_type
|
|
falsename() const
|
|
{ return this->do_falsename(); }
|
|
|
|
protected:
|
|
|
|
virtual
|
|
~numpunct();
|
|
# 1793 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_decimal_point() const
|
|
{ return _M_data->_M_decimal_point; }
|
|
# 1805 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual char_type
|
|
do_thousands_sep() const
|
|
{ return _M_data->_M_thousands_sep; }
|
|
# 1818 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual string
|
|
do_grouping() const
|
|
{ return _M_data->_M_grouping; }
|
|
# 1831 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual string_type
|
|
do_truename() const
|
|
{ return _M_data->_M_truename; }
|
|
# 1844 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual string_type
|
|
do_falsename() const
|
|
{ return _M_data->_M_falsename; }
|
|
|
|
|
|
void
|
|
_M_initialize_numpunct(__c_locale __cloc = 0);
|
|
};
|
|
|
|
template<typename _CharT>
|
|
locale::id numpunct<_CharT>::id;
|
|
|
|
template<>
|
|
numpunct<char>::~numpunct();
|
|
|
|
template<>
|
|
void
|
|
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
|
|
|
|
|
|
template<>
|
|
numpunct<wchar_t>::~numpunct();
|
|
|
|
template<>
|
|
void
|
|
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
class numpunct_byname : public numpunct<_CharT>
|
|
{
|
|
public:
|
|
typedef _CharT char_type;
|
|
typedef basic_string<_CharT> string_type;
|
|
|
|
explicit
|
|
numpunct_byname(const char* __s, size_t __refs = 0)
|
|
: numpunct<_CharT>(__refs)
|
|
{
|
|
if (__builtin_strcmp(__s, "C") != 0
|
|
&& __builtin_strcmp(__s, "POSIX") != 0)
|
|
{
|
|
__c_locale __tmp;
|
|
this->_S_create_c_locale(__tmp, __s);
|
|
this->_M_initialize_numpunct(__tmp);
|
|
this->_S_destroy_c_locale(__tmp);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
virtual
|
|
~numpunct_byname() { }
|
|
};
|
|
|
|
|
|
# 1914 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<typename _CharT, typename _InIter>
|
|
class num_get : public locale::facet
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef _InIter iter_type;
|
|
|
|
|
|
|
|
static locale::id id;
|
|
# 1935 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
num_get(size_t __refs = 0) : facet(__refs) { }
|
|
# 1961 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, bool& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
# 1998 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, long& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned short& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned int& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned long& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, long long& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned long long& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
# 2058 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, float& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, double& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, long double& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
# 2101 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
get(iter_type __in, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, void*& __v) const
|
|
{ return this->do_get(__in, __end, __io, __err, __v); }
|
|
|
|
protected:
|
|
|
|
virtual ~num_get() { }
|
|
|
|
iter_type
|
|
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
|
|
string&) const;
|
|
|
|
template<typename _ValueT>
|
|
iter_type
|
|
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
|
|
_ValueT&) const;
|
|
|
|
template<typename _CharT2>
|
|
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
|
|
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
|
|
{
|
|
int __ret = -1;
|
|
if (__len <= 10)
|
|
{
|
|
if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
|
|
__ret = __c - _CharT2('0');
|
|
}
|
|
else
|
|
{
|
|
if (__c >= _CharT2('0') && __c <= _CharT2('9'))
|
|
__ret = __c - _CharT2('0');
|
|
else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
|
|
__ret = 10 + (__c - _CharT2('a'));
|
|
else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
|
|
__ret = 10 + (__c - _CharT2('A'));
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT2>
|
|
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
|
|
int>::__type
|
|
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
|
|
{
|
|
int __ret = -1;
|
|
const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
|
|
if (__q)
|
|
{
|
|
__ret = __q - __zero;
|
|
if (__ret > 15)
|
|
__ret -= 6;
|
|
}
|
|
return __ret;
|
|
}
|
|
# 2172 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual iter_type
|
|
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
|
|
|
|
virtual iter_type
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, long& __v) const
|
|
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
|
|
|
|
virtual iter_type
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned short& __v) const
|
|
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
|
|
|
|
virtual iter_type
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned int& __v) const
|
|
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
|
|
|
|
virtual iter_type
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned long& __v) const
|
|
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
|
|
|
|
|
|
virtual iter_type
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, long long& __v) const
|
|
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
|
|
|
|
virtual iter_type
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, unsigned long long& __v) const
|
|
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
|
|
|
|
|
|
virtual iter_type
|
|
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
|
|
|
|
virtual iter_type
|
|
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
|
|
double&) const;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual iter_type
|
|
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
|
|
long double&) const;
|
|
|
|
|
|
virtual iter_type
|
|
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
|
|
# 2235 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
};
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
locale::id num_get<_CharT, _InIter>::id;
|
|
# 2253 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
template<typename _CharT, typename _OutIter>
|
|
class num_put : public locale::facet
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
typedef _CharT char_type;
|
|
typedef _OutIter iter_type;
|
|
|
|
|
|
|
|
static locale::id id;
|
|
# 2274 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
explicit
|
|
num_put(size_t __refs = 0) : facet(__refs) { }
|
|
# 2292 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
# 2334 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill,
|
|
unsigned long __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
|
|
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill,
|
|
unsigned long long __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
# 2397 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill,
|
|
long double __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
# 2422 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
iter_type
|
|
put(iter_type __s, ios_base& __io, char_type __fill,
|
|
const void* __v) const
|
|
{ return this->do_put(__s, __io, __fill, __v); }
|
|
|
|
protected:
|
|
template<typename _ValueT>
|
|
iter_type
|
|
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
|
|
char __mod, _ValueT __v) const;
|
|
|
|
void
|
|
_M_group_float(const char* __grouping, size_t __grouping_size,
|
|
char_type __sep, const char_type* __p, char_type* __new,
|
|
char_type* __cs, int& __len) const;
|
|
|
|
template<typename _ValueT>
|
|
iter_type
|
|
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
|
|
_ValueT __v) const;
|
|
|
|
void
|
|
_M_group_int(const char* __grouping, size_t __grouping_size,
|
|
char_type __sep, ios_base& __io, char_type* __new,
|
|
char_type* __cs, int& __len) const;
|
|
|
|
void
|
|
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
|
|
char_type* __new, const char_type* __cs, int& __len) const;
|
|
|
|
|
|
virtual
|
|
~num_put() { };
|
|
# 2470 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
|
|
virtual iter_type
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
|
|
|
|
virtual iter_type
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
|
|
{ return _M_insert_int(__s, __io, __fill, __v); }
|
|
|
|
virtual iter_type
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill,
|
|
unsigned long __v) const
|
|
{ return _M_insert_int(__s, __io, __fill, __v); }
|
|
|
|
|
|
virtual iter_type
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill,
|
|
long long __v) const
|
|
{ return _M_insert_int(__s, __io, __fill, __v); }
|
|
|
|
virtual iter_type
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill,
|
|
unsigned long long __v) const
|
|
{ return _M_insert_int(__s, __io, __fill, __v); }
|
|
|
|
|
|
virtual iter_type
|
|
do_put(iter_type, ios_base&, char_type, double) const;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual iter_type
|
|
do_put(iter_type, ios_base&, char_type, long double) const;
|
|
|
|
|
|
virtual iter_type
|
|
do_put(iter_type, ios_base&, char_type, const void*) const;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
template <typename _CharT, typename _OutIter>
|
|
locale::id num_put<_CharT, _OutIter>::id;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isspace(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isprint(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
iscntrl(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isupper(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
islower(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isalpha(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isdigit(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
ispunct(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isxdigit(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isalnum(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline bool
|
|
isgraph(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline _CharT
|
|
toupper(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
|
|
|
|
|
|
template<typename _CharT>
|
|
inline _CharT
|
|
tolower(_CharT __c, const locale& __loc)
|
|
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
|
|
|
|
|
|
}
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
template<typename _Facet>
|
|
struct __use_cache
|
|
{
|
|
const _Facet*
|
|
operator() (const locale& __loc) const;
|
|
};
|
|
|
|
|
|
template<typename _CharT>
|
|
struct __use_cache<__numpunct_cache<_CharT> >
|
|
{
|
|
const __numpunct_cache<_CharT>*
|
|
operator() (const locale& __loc) const
|
|
{
|
|
const size_t __i = numpunct<_CharT>::id._M_id();
|
|
const locale::facet** __caches = __loc._M_impl->_M_caches;
|
|
if (!__caches[__i])
|
|
{
|
|
__numpunct_cache<_CharT>* __tmp = 0;
|
|
try
|
|
{
|
|
__tmp = new __numpunct_cache<_CharT>;
|
|
__tmp->_M_cache(__loc);
|
|
}
|
|
catch(...)
|
|
{
|
|
delete __tmp;
|
|
throw;
|
|
}
|
|
__loc._M_impl->_M_install_cache(__tmp, __i);
|
|
}
|
|
return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
|
|
}
|
|
};
|
|
|
|
template<typename _CharT>
|
|
void
|
|
__numpunct_cache<_CharT>::_M_cache(const locale& __loc)
|
|
{
|
|
_M_allocated = true;
|
|
|
|
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
|
|
|
|
char* __grouping = 0;
|
|
_CharT* __truename = 0;
|
|
_CharT* __falsename = 0;
|
|
try
|
|
{
|
|
_M_grouping_size = __np.grouping().size();
|
|
__grouping = new char[_M_grouping_size];
|
|
__np.grouping().copy(__grouping, _M_grouping_size);
|
|
_M_grouping = __grouping;
|
|
_M_use_grouping = (_M_grouping_size
|
|
&& static_cast<signed char>(_M_grouping[0]) > 0
|
|
&& (_M_grouping[0]
|
|
!= __gnu_cxx::__numeric_traits<char>::__max));
|
|
|
|
_M_truename_size = __np.truename().size();
|
|
__truename = new _CharT[_M_truename_size];
|
|
__np.truename().copy(__truename, _M_truename_size);
|
|
_M_truename = __truename;
|
|
|
|
_M_falsename_size = __np.falsename().size();
|
|
__falsename = new _CharT[_M_falsename_size];
|
|
__np.falsename().copy(__falsename, _M_falsename_size);
|
|
_M_falsename = __falsename;
|
|
|
|
_M_decimal_point = __np.decimal_point();
|
|
_M_thousands_sep = __np.thousands_sep();
|
|
|
|
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
|
|
__ct.widen(__num_base::_S_atoms_out,
|
|
__num_base::_S_atoms_out
|
|
+ __num_base::_S_oend, _M_atoms_out);
|
|
__ct.widen(__num_base::_S_atoms_in,
|
|
__num_base::_S_atoms_in
|
|
+ __num_base::_S_iend, _M_atoms_in);
|
|
}
|
|
catch(...)
|
|
{
|
|
delete [] __grouping;
|
|
delete [] __truename;
|
|
delete [] __falsename;
|
|
throw;
|
|
}
|
|
}
|
|
# 136 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
__attribute__ ((__pure__)) bool
|
|
__verify_grouping(const char* __grouping, size_t __grouping_size,
|
|
const string& __grouping_tmp) throw ();
|
|
|
|
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
_M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
|
|
ios_base::iostate& __err, string& __xtrc) const
|
|
{
|
|
typedef char_traits<_CharT> __traits_type;
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
__use_cache<__cache_type> __uc;
|
|
const locale& __loc = __io._M_getloc();
|
|
const __cache_type* __lc = __uc(__loc);
|
|
const _CharT* __lit = __lc->_M_atoms_in;
|
|
char_type __c = char_type();
|
|
|
|
|
|
bool __testeof = __beg == __end;
|
|
|
|
|
|
if (!__testeof)
|
|
{
|
|
__c = *__beg;
|
|
const bool __plus = __c == __lit[__num_base::_S_iplus];
|
|
if ((__plus || __c == __lit[__num_base::_S_iminus])
|
|
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|
|
&& !(__c == __lc->_M_decimal_point))
|
|
{
|
|
__xtrc += __plus ? '+' : '-';
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
}
|
|
|
|
|
|
bool __found_mantissa = false;
|
|
int __sep_pos = 0;
|
|
while (!__testeof)
|
|
{
|
|
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|
|
|| __c == __lc->_M_decimal_point)
|
|
break;
|
|
else if (__c == __lit[__num_base::_S_izero])
|
|
{
|
|
if (!__found_mantissa)
|
|
{
|
|
__xtrc += '0';
|
|
__found_mantissa = true;
|
|
}
|
|
++__sep_pos;
|
|
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
|
|
bool __found_dec = false;
|
|
bool __found_sci = false;
|
|
string __found_grouping;
|
|
if (__lc->_M_use_grouping)
|
|
__found_grouping.reserve(32);
|
|
const char_type* __lit_zero = __lit + __num_base::_S_izero;
|
|
|
|
if (!__lc->_M_allocated)
|
|
|
|
while (!__testeof)
|
|
{
|
|
const int __digit = _M_find(__lit_zero, 10, __c);
|
|
if (__digit != -1)
|
|
{
|
|
__xtrc += '0' + __digit;
|
|
__found_mantissa = true;
|
|
}
|
|
else if (__c == __lc->_M_decimal_point
|
|
&& !__found_dec && !__found_sci)
|
|
{
|
|
__xtrc += '.';
|
|
__found_dec = true;
|
|
}
|
|
else if ((__c == __lit[__num_base::_S_ie]
|
|
|| __c == __lit[__num_base::_S_iE])
|
|
&& !__found_sci && __found_mantissa)
|
|
{
|
|
|
|
__xtrc += 'e';
|
|
__found_sci = true;
|
|
|
|
|
|
if (++__beg != __end)
|
|
{
|
|
__c = *__beg;
|
|
const bool __plus = __c == __lit[__num_base::_S_iplus];
|
|
if (__plus || __c == __lit[__num_base::_S_iminus])
|
|
__xtrc += __plus ? '+' : '-';
|
|
else
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
__testeof = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
else
|
|
while (!__testeof)
|
|
{
|
|
|
|
|
|
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|
|
{
|
|
if (!__found_dec && !__found_sci)
|
|
{
|
|
|
|
|
|
if (__sep_pos)
|
|
{
|
|
__found_grouping += static_cast<char>(__sep_pos);
|
|
__sep_pos = 0;
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
__xtrc.clear();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else if (__c == __lc->_M_decimal_point)
|
|
{
|
|
if (!__found_dec && !__found_sci)
|
|
{
|
|
|
|
|
|
|
|
if (__found_grouping.size())
|
|
__found_grouping += static_cast<char>(__sep_pos);
|
|
__xtrc += '.';
|
|
__found_dec = true;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
const char_type* __q =
|
|
__traits_type::find(__lit_zero, 10, __c);
|
|
if (__q)
|
|
{
|
|
__xtrc += '0' + (__q - __lit_zero);
|
|
__found_mantissa = true;
|
|
++__sep_pos;
|
|
}
|
|
else if ((__c == __lit[__num_base::_S_ie]
|
|
|| __c == __lit[__num_base::_S_iE])
|
|
&& !__found_sci && __found_mantissa)
|
|
{
|
|
|
|
if (__found_grouping.size() && !__found_dec)
|
|
__found_grouping += static_cast<char>(__sep_pos);
|
|
__xtrc += 'e';
|
|
__found_sci = true;
|
|
|
|
|
|
if (++__beg != __end)
|
|
{
|
|
__c = *__beg;
|
|
const bool __plus = __c == __lit[__num_base::_S_iplus];
|
|
if ((__plus || __c == __lit[__num_base::_S_iminus])
|
|
&& !(__lc->_M_use_grouping
|
|
&& __c == __lc->_M_thousands_sep)
|
|
&& !(__c == __lc->_M_decimal_point))
|
|
__xtrc += __plus ? '+' : '-';
|
|
else
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
__testeof = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
|
|
|
|
|
|
if (__found_grouping.size())
|
|
{
|
|
|
|
if (!__found_dec && !__found_sci)
|
|
__found_grouping += static_cast<char>(__sep_pos);
|
|
|
|
if (!std::__verify_grouping(__lc->_M_grouping,
|
|
__lc->_M_grouping_size,
|
|
__found_grouping))
|
|
__err = ios_base::failbit;
|
|
}
|
|
|
|
return __beg;
|
|
}
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
template<typename _ValueT>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
_M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
|
|
ios_base::iostate& __err, _ValueT& __v) const
|
|
{
|
|
typedef char_traits<_CharT> __traits_type;
|
|
using __gnu_cxx::__add_unsigned;
|
|
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
__use_cache<__cache_type> __uc;
|
|
const locale& __loc = __io._M_getloc();
|
|
const __cache_type* __lc = __uc(__loc);
|
|
const _CharT* __lit = __lc->_M_atoms_in;
|
|
char_type __c = char_type();
|
|
|
|
|
|
const ios_base::fmtflags __basefield = __io.flags()
|
|
& ios_base::basefield;
|
|
const bool __oct = __basefield == ios_base::oct;
|
|
int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
|
|
|
|
|
|
bool __testeof = __beg == __end;
|
|
|
|
|
|
bool __negative = false;
|
|
if (!__testeof)
|
|
{
|
|
__c = *__beg;
|
|
__negative = __c == __lit[__num_base::_S_iminus];
|
|
if ((__negative || __c == __lit[__num_base::_S_iplus])
|
|
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|
|
&& !(__c == __lc->_M_decimal_point))
|
|
{
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
bool __found_zero = false;
|
|
int __sep_pos = 0;
|
|
while (!__testeof)
|
|
{
|
|
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|
|
|| __c == __lc->_M_decimal_point)
|
|
break;
|
|
else if (__c == __lit[__num_base::_S_izero]
|
|
&& (!__found_zero || __base == 10))
|
|
{
|
|
__found_zero = true;
|
|
++__sep_pos;
|
|
if (__basefield == 0)
|
|
__base = 8;
|
|
if (__base == 8)
|
|
__sep_pos = 0;
|
|
}
|
|
else if (__found_zero
|
|
&& (__c == __lit[__num_base::_S_ix]
|
|
|| __c == __lit[__num_base::_S_iX]))
|
|
{
|
|
if (__basefield == 0)
|
|
__base = 16;
|
|
if (__base == 16)
|
|
{
|
|
__found_zero = false;
|
|
__sep_pos = 0;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
|
|
if (++__beg != __end)
|
|
{
|
|
__c = *__beg;
|
|
if (!__found_zero)
|
|
break;
|
|
}
|
|
else
|
|
__testeof = true;
|
|
}
|
|
|
|
|
|
|
|
const size_t __len = (__base == 16 ? __num_base::_S_iend
|
|
- __num_base::_S_izero : __base);
|
|
|
|
|
|
string __found_grouping;
|
|
if (__lc->_M_use_grouping)
|
|
__found_grouping.reserve(32);
|
|
bool __testfail = false;
|
|
bool __testoverflow = false;
|
|
const __unsigned_type __max =
|
|
(__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
|
|
? -__gnu_cxx::__numeric_traits<_ValueT>::__min
|
|
: __gnu_cxx::__numeric_traits<_ValueT>::__max;
|
|
const __unsigned_type __smax = __max / __base;
|
|
__unsigned_type __result = 0;
|
|
int __digit = 0;
|
|
const char_type* __lit_zero = __lit + __num_base::_S_izero;
|
|
|
|
if (!__lc->_M_allocated)
|
|
|
|
while (!__testeof)
|
|
{
|
|
__digit = _M_find(__lit_zero, __len, __c);
|
|
if (__digit == -1)
|
|
break;
|
|
|
|
if (__result > __smax)
|
|
__testoverflow = true;
|
|
else
|
|
{
|
|
__result *= __base;
|
|
__testoverflow |= __result > __max - __digit;
|
|
__result += __digit;
|
|
++__sep_pos;
|
|
}
|
|
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
else
|
|
while (!__testeof)
|
|
{
|
|
|
|
|
|
if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|
|
{
|
|
|
|
|
|
if (__sep_pos)
|
|
{
|
|
__found_grouping += static_cast<char>(__sep_pos);
|
|
__sep_pos = 0;
|
|
}
|
|
else
|
|
{
|
|
__testfail = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (__c == __lc->_M_decimal_point)
|
|
break;
|
|
else
|
|
{
|
|
const char_type* __q =
|
|
__traits_type::find(__lit_zero, __len, __c);
|
|
if (!__q)
|
|
break;
|
|
|
|
__digit = __q - __lit_zero;
|
|
if (__digit > 15)
|
|
__digit -= 6;
|
|
if (__result > __smax)
|
|
__testoverflow = true;
|
|
else
|
|
{
|
|
__result *= __base;
|
|
__testoverflow |= __result > __max - __digit;
|
|
__result += __digit;
|
|
++__sep_pos;
|
|
}
|
|
}
|
|
|
|
if (++__beg != __end)
|
|
__c = *__beg;
|
|
else
|
|
__testeof = true;
|
|
}
|
|
|
|
|
|
|
|
if (__found_grouping.size())
|
|
{
|
|
|
|
__found_grouping += static_cast<char>(__sep_pos);
|
|
|
|
if (!std::__verify_grouping(__lc->_M_grouping,
|
|
__lc->_M_grouping_size,
|
|
__found_grouping))
|
|
__err = ios_base::failbit;
|
|
}
|
|
|
|
|
|
|
|
if ((!__sep_pos && !__found_zero && !__found_grouping.size())
|
|
|| __testfail)
|
|
{
|
|
__v = 0;
|
|
__err = ios_base::failbit;
|
|
}
|
|
else if (__testoverflow)
|
|
{
|
|
if (__negative
|
|
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
|
|
__v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
|
|
else
|
|
__v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
|
|
__err = ios_base::failbit;
|
|
}
|
|
else
|
|
__v = __negative ? -__result : __result;
|
|
|
|
if (__testeof)
|
|
__err |= ios_base::eofbit;
|
|
return __beg;
|
|
}
|
|
|
|
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, bool& __v) const
|
|
{
|
|
if (!(__io.flags() & ios_base::boolalpha))
|
|
{
|
|
|
|
|
|
|
|
long __l = -1;
|
|
__beg = _M_extract_int(__beg, __end, __io, __err, __l);
|
|
if (__l == 0 || __l == 1)
|
|
__v = bool(__l);
|
|
else
|
|
{
|
|
|
|
|
|
__v = true;
|
|
__err = ios_base::failbit;
|
|
if (__beg == __end)
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
__use_cache<__cache_type> __uc;
|
|
const locale& __loc = __io._M_getloc();
|
|
const __cache_type* __lc = __uc(__loc);
|
|
|
|
bool __testf = true;
|
|
bool __testt = true;
|
|
bool __donef = __lc->_M_falsename_size == 0;
|
|
bool __donet = __lc->_M_truename_size == 0;
|
|
bool __testeof = false;
|
|
size_t __n = 0;
|
|
while (!__donef || !__donet)
|
|
{
|
|
if (__beg == __end)
|
|
{
|
|
__testeof = true;
|
|
break;
|
|
}
|
|
|
|
const char_type __c = *__beg;
|
|
|
|
if (!__donef)
|
|
__testf = __c == __lc->_M_falsename[__n];
|
|
|
|
if (!__testf && __donet)
|
|
break;
|
|
|
|
if (!__donet)
|
|
__testt = __c == __lc->_M_truename[__n];
|
|
|
|
if (!__testt && __donef)
|
|
break;
|
|
|
|
if (!__testt && !__testf)
|
|
break;
|
|
|
|
++__n;
|
|
++__beg;
|
|
|
|
__donef = !__testf || __n >= __lc->_M_falsename_size;
|
|
__donet = !__testt || __n >= __lc->_M_truename_size;
|
|
}
|
|
if (__testf && __n == __lc->_M_falsename_size && __n)
|
|
{
|
|
__v = false;
|
|
if (__testt && __n == __lc->_M_truename_size)
|
|
__err = ios_base::failbit;
|
|
else
|
|
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
|
|
}
|
|
else if (__testt && __n == __lc->_M_truename_size && __n)
|
|
{
|
|
__v = true;
|
|
__err = __testeof ? ios_base::eofbit : ios_base::goodbit;
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
__v = false;
|
|
__err = ios_base::failbit;
|
|
if (__testeof)
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
}
|
|
return __beg;
|
|
}
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, float& __v) const
|
|
{
|
|
string __xtrc;
|
|
__xtrc.reserve(32);
|
|
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
|
|
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
|
|
if (__beg == __end)
|
|
__err |= ios_base::eofbit;
|
|
return __beg;
|
|
}
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, double& __v) const
|
|
{
|
|
string __xtrc;
|
|
__xtrc.reserve(32);
|
|
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
|
|
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
|
|
if (__beg == __end)
|
|
__err |= ios_base::eofbit;
|
|
return __beg;
|
|
}
|
|
# 730 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
template<typename _CharT, typename _InIter>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, long double& __v) const
|
|
{
|
|
string __xtrc;
|
|
__xtrc.reserve(32);
|
|
__beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
|
|
std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
|
|
if (__beg == __end)
|
|
__err |= ios_base::eofbit;
|
|
return __beg;
|
|
}
|
|
|
|
template<typename _CharT, typename _InIter>
|
|
_InIter
|
|
num_get<_CharT, _InIter>::
|
|
do_get(iter_type __beg, iter_type __end, ios_base& __io,
|
|
ios_base::iostate& __err, void*& __v) const
|
|
{
|
|
|
|
typedef ios_base::fmtflags fmtflags;
|
|
const fmtflags __fmt = __io.flags();
|
|
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
|
|
|
|
typedef __gnu_cxx::__conditional_type<(sizeof(void*)
|
|
<= sizeof(unsigned long)),
|
|
unsigned long, unsigned long long>::__type _UIntPtrType;
|
|
|
|
_UIntPtrType __ul;
|
|
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);
|
|
|
|
|
|
__io.flags(__fmt);
|
|
|
|
__v = reinterpret_cast<void*>(__ul);
|
|
return __beg;
|
|
}
|
|
|
|
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
void
|
|
num_put<_CharT, _OutIter>::
|
|
_M_pad(_CharT __fill, streamsize __w, ios_base& __io,
|
|
_CharT* __new, const _CharT* __cs, int& __len) const
|
|
{
|
|
|
|
|
|
__pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
|
|
__cs, __w, __len);
|
|
__len = static_cast<int>(__w);
|
|
}
|
|
|
|
|
|
|
|
template<typename _CharT, typename _ValueT>
|
|
int
|
|
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
|
|
ios_base::fmtflags __flags, bool __dec)
|
|
{
|
|
_CharT* __buf = __bufend;
|
|
if (__builtin_expect(__dec, true))
|
|
{
|
|
|
|
do
|
|
{
|
|
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
|
|
__v /= 10;
|
|
}
|
|
while (__v != 0);
|
|
}
|
|
else if ((__flags & ios_base::basefield) == ios_base::oct)
|
|
{
|
|
|
|
do
|
|
{
|
|
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
|
|
__v >>= 3;
|
|
}
|
|
while (__v != 0);
|
|
}
|
|
else
|
|
{
|
|
|
|
const bool __uppercase = __flags & ios_base::uppercase;
|
|
const int __case_offset = __uppercase ? __num_base::_S_oudigits
|
|
: __num_base::_S_odigits;
|
|
do
|
|
{
|
|
*--__buf = __lit[(__v & 0xf) + __case_offset];
|
|
__v >>= 4;
|
|
}
|
|
while (__v != 0);
|
|
}
|
|
return __bufend - __buf;
|
|
}
|
|
|
|
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
void
|
|
num_put<_CharT, _OutIter>::
|
|
_M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
|
|
ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
|
|
{
|
|
_CharT* __p = std::__add_grouping(__new, __sep, __grouping,
|
|
__grouping_size, __cs, __cs + __len);
|
|
__len = __p - __new;
|
|
}
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
template<typename _ValueT>
|
|
_OutIter
|
|
num_put<_CharT, _OutIter>::
|
|
_M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
|
|
_ValueT __v) const
|
|
{
|
|
using __gnu_cxx::__add_unsigned;
|
|
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
__use_cache<__cache_type> __uc;
|
|
const locale& __loc = __io._M_getloc();
|
|
const __cache_type* __lc = __uc(__loc);
|
|
const _CharT* __lit = __lc->_M_atoms_out;
|
|
const ios_base::fmtflags __flags = __io.flags();
|
|
|
|
|
|
const int __ilen = 5 * sizeof(_ValueT);
|
|
_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* __ilen));
|
|
|
|
|
|
|
|
const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
|
|
const bool __dec = (__basefield != ios_base::oct
|
|
&& __basefield != ios_base::hex);
|
|
const __unsigned_type __u = ((__v > 0 || !__dec)
|
|
? __unsigned_type(__v)
|
|
: -__unsigned_type(__v));
|
|
int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
|
|
__cs += __ilen - __len;
|
|
|
|
|
|
if (__lc->_M_use_grouping)
|
|
{
|
|
|
|
|
|
_CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* (__len + 1)
|
|
* 2));
|
|
_M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
|
|
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
|
|
__cs = __cs2 + 2;
|
|
}
|
|
|
|
|
|
if (__builtin_expect(__dec, true))
|
|
{
|
|
|
|
if (__v >= 0)
|
|
{
|
|
if (bool(__flags & ios_base::showpos)
|
|
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
|
|
*--__cs = __lit[__num_base::_S_oplus], ++__len;
|
|
}
|
|
else
|
|
*--__cs = __lit[__num_base::_S_ominus], ++__len;
|
|
}
|
|
else if (bool(__flags & ios_base::showbase) && __v)
|
|
{
|
|
if (__basefield == ios_base::oct)
|
|
*--__cs = __lit[__num_base::_S_odigits], ++__len;
|
|
else
|
|
{
|
|
|
|
const bool __uppercase = __flags & ios_base::uppercase;
|
|
*--__cs = __lit[__num_base::_S_ox + __uppercase];
|
|
|
|
*--__cs = __lit[__num_base::_S_odigits];
|
|
__len += 2;
|
|
}
|
|
}
|
|
|
|
|
|
const streamsize __w = __io.width();
|
|
if (__w > static_cast<streamsize>(__len))
|
|
{
|
|
_CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* __w));
|
|
_M_pad(__fill, __w, __io, __cs3, __cs, __len);
|
|
__cs = __cs3;
|
|
}
|
|
__io.width(0);
|
|
|
|
|
|
|
|
return std::__write(__s, __cs, __len);
|
|
}
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
void
|
|
num_put<_CharT, _OutIter>::
|
|
_M_group_float(const char* __grouping, size_t __grouping_size,
|
|
_CharT __sep, const _CharT* __p, _CharT* __new,
|
|
_CharT* __cs, int& __len) const
|
|
{
|
|
|
|
|
|
|
|
const int __declen = __p ? __p - __cs : __len;
|
|
_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
|
|
__grouping_size,
|
|
__cs, __cs + __declen);
|
|
|
|
|
|
int __newlen = __p2 - __new;
|
|
if (__p)
|
|
{
|
|
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
|
|
__newlen += __len - __declen;
|
|
}
|
|
__len = __newlen;
|
|
}
|
|
# 966 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
template<typename _CharT, typename _OutIter>
|
|
template<typename _ValueT>
|
|
_OutIter
|
|
num_put<_CharT, _OutIter>::
|
|
_M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
|
|
_ValueT __v) const
|
|
{
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
__use_cache<__cache_type> __uc;
|
|
const locale& __loc = __io._M_getloc();
|
|
const __cache_type* __lc = __uc(__loc);
|
|
|
|
|
|
const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
|
|
|
|
const int __max_digits =
|
|
__gnu_cxx::__numeric_traits<_ValueT>::__digits10;
|
|
|
|
|
|
int __len;
|
|
|
|
char __fbuf[16];
|
|
__num_base::_S_format_float(__io, __fbuf, __mod);
|
|
|
|
|
|
|
|
|
|
int __cs_size = __max_digits * 3;
|
|
char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
|
|
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
|
|
__fbuf, __prec, __v);
|
|
|
|
|
|
if (__len >= __cs_size)
|
|
{
|
|
__cs_size = __len + 1;
|
|
__cs = static_cast<char*>(__builtin_alloca(__cs_size));
|
|
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
|
|
__fbuf, __prec, __v);
|
|
}
|
|
# 1027 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
|
|
|
|
_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* __len));
|
|
__ctype.widen(__cs, __cs + __len, __ws);
|
|
|
|
|
|
_CharT* __wp = 0;
|
|
const char* __p = char_traits<char>::find(__cs, __len, '.');
|
|
if (__p)
|
|
{
|
|
__wp = __ws + (__p - __cs);
|
|
*__wp = __lc->_M_decimal_point;
|
|
}
|
|
|
|
|
|
|
|
|
|
if (__lc->_M_use_grouping
|
|
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
|
|
&& __cs[1] >= '0' && __cs[2] >= '0')))
|
|
{
|
|
|
|
|
|
_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* __len * 2));
|
|
|
|
streamsize __off = 0;
|
|
if (__cs[0] == '-' || __cs[0] == '+')
|
|
{
|
|
__off = 1;
|
|
__ws2[0] = __ws[0];
|
|
__len -= 1;
|
|
}
|
|
|
|
_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
|
|
__lc->_M_thousands_sep, __wp, __ws2 + __off,
|
|
__ws + __off, __len);
|
|
__len += __off;
|
|
|
|
__ws = __ws2;
|
|
}
|
|
|
|
|
|
const streamsize __w = __io.width();
|
|
if (__w > static_cast<streamsize>(__len))
|
|
{
|
|
_CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* __w));
|
|
_M_pad(__fill, __w, __io, __ws3, __ws, __len);
|
|
__ws = __ws3;
|
|
}
|
|
__io.width(0);
|
|
|
|
|
|
|
|
return std::__write(__s, __ws, __len);
|
|
}
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
_OutIter
|
|
num_put<_CharT, _OutIter>::
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
|
|
{
|
|
const ios_base::fmtflags __flags = __io.flags();
|
|
if ((__flags & ios_base::boolalpha) == 0)
|
|
{
|
|
const long __l = __v;
|
|
__s = _M_insert_int(__s, __io, __fill, __l);
|
|
}
|
|
else
|
|
{
|
|
typedef __numpunct_cache<_CharT> __cache_type;
|
|
__use_cache<__cache_type> __uc;
|
|
const locale& __loc = __io._M_getloc();
|
|
const __cache_type* __lc = __uc(__loc);
|
|
|
|
const _CharT* __name = __v ? __lc->_M_truename
|
|
: __lc->_M_falsename;
|
|
int __len = __v ? __lc->_M_truename_size
|
|
: __lc->_M_falsename_size;
|
|
|
|
const streamsize __w = __io.width();
|
|
if (__w > static_cast<streamsize>(__len))
|
|
{
|
|
const streamsize __plen = __w - __len;
|
|
_CharT* __ps
|
|
= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
|
|
* __plen));
|
|
|
|
char_traits<_CharT>::assign(__ps, __plen, __fill);
|
|
__io.width(0);
|
|
|
|
if ((__flags & ios_base::adjustfield) == ios_base::left)
|
|
{
|
|
__s = std::__write(__s, __name, __len);
|
|
__s = std::__write(__s, __ps, __plen);
|
|
}
|
|
else
|
|
{
|
|
__s = std::__write(__s, __ps, __plen);
|
|
__s = std::__write(__s, __name, __len);
|
|
}
|
|
return __s;
|
|
}
|
|
__io.width(0);
|
|
__s = std::__write(__s, __name, __len);
|
|
}
|
|
return __s;
|
|
}
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
_OutIter
|
|
num_put<_CharT, _OutIter>::
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
|
|
{ return _M_insert_float(__s, __io, __fill, char(), __v); }
|
|
# 1152 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
template<typename _CharT, typename _OutIter>
|
|
_OutIter
|
|
num_put<_CharT, _OutIter>::
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill,
|
|
long double __v) const
|
|
{ return _M_insert_float(__s, __io, __fill, 'L', __v); }
|
|
|
|
template<typename _CharT, typename _OutIter>
|
|
_OutIter
|
|
num_put<_CharT, _OutIter>::
|
|
do_put(iter_type __s, ios_base& __io, char_type __fill,
|
|
const void* __v) const
|
|
{
|
|
const ios_base::fmtflags __flags = __io.flags();
|
|
const ios_base::fmtflags __fmt = ~(ios_base::basefield
|
|
| ios_base::uppercase);
|
|
__io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
|
|
|
|
typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
|
|
<= sizeof(unsigned long)),
|
|
unsigned long, unsigned long long>::__type _UIntPtrType;
|
|
|
|
__s = _M_insert_int(__s, __io, __fill,
|
|
reinterpret_cast<_UIntPtrType>(__v));
|
|
__io.flags(__flags);
|
|
return __s;
|
|
}
|
|
|
|
|
|
# 1189 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
|
|
template<typename _CharT, typename _Traits>
|
|
void
|
|
__pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
|
|
_CharT* __news, const _CharT* __olds,
|
|
streamsize __newlen, streamsize __oldlen)
|
|
{
|
|
const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
|
|
const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
|
|
|
|
|
|
if (__adjust == ios_base::left)
|
|
{
|
|
_Traits::copy(__news, __olds, __oldlen);
|
|
_Traits::assign(__news + __oldlen, __plen, __fill);
|
|
return;
|
|
}
|
|
|
|
size_t __mod = 0;
|
|
if (__adjust == ios_base::internal)
|
|
{
|
|
|
|
|
|
|
|
const locale& __loc = __io._M_getloc();
|
|
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
|
|
|
|
if (__ctype.widen('-') == __olds[0]
|
|
|| __ctype.widen('+') == __olds[0])
|
|
{
|
|
__news[0] = __olds[0];
|
|
__mod = 1;
|
|
++__news;
|
|
}
|
|
else if (__ctype.widen('0') == __olds[0]
|
|
&& __oldlen > 1
|
|
&& (__ctype.widen('x') == __olds[1]
|
|
|| __ctype.widen('X') == __olds[1]))
|
|
{
|
|
__news[0] = __olds[0];
|
|
__news[1] = __olds[1];
|
|
__mod = 2;
|
|
__news += 2;
|
|
}
|
|
|
|
}
|
|
_Traits::assign(__news, __plen, __fill);
|
|
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
|
|
}
|
|
|
|
template<typename _CharT>
|
|
_CharT*
|
|
__add_grouping(_CharT* __s, _CharT __sep,
|
|
const char* __gbeg, size_t __gsize,
|
|
const _CharT* __first, const _CharT* __last)
|
|
{
|
|
size_t __idx = 0;
|
|
size_t __ctr = 0;
|
|
|
|
while (__last - __first > __gbeg[__idx]
|
|
&& static_cast<signed char>(__gbeg[__idx]) > 0
|
|
&& __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
|
|
{
|
|
__last -= __gbeg[__idx];
|
|
__idx < __gsize - 1 ? ++__idx : ++__ctr;
|
|
}
|
|
|
|
while (__first != __last)
|
|
*__s++ = *__first++;
|
|
|
|
while (__ctr--)
|
|
{
|
|
*__s++ = __sep;
|
|
for (char __i = __gbeg[__idx]; __i > 0; --__i)
|
|
*__s++ = *__first++;
|
|
}
|
|
|
|
while (__idx--)
|
|
{
|
|
*__s++ = __sep;
|
|
for (char __i = __gbeg[__idx]; __i > 0; --__i)
|
|
*__s++ = *__first++;
|
|
}
|
|
|
|
return __s;
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class numpunct<char>;
|
|
extern template class numpunct_byname<char>;
|
|
extern template class num_get<char>;
|
|
extern template class num_put<char>;
|
|
extern template class ctype_byname<char>;
|
|
|
|
extern template
|
|
const ctype<char>&
|
|
use_facet<ctype<char> >(const locale&);
|
|
|
|
extern template
|
|
const numpunct<char>&
|
|
use_facet<numpunct<char> >(const locale&);
|
|
|
|
extern template
|
|
const num_put<char>&
|
|
use_facet<num_put<char> >(const locale&);
|
|
|
|
extern template
|
|
const num_get<char>&
|
|
use_facet<num_get<char> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<ctype<char> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<numpunct<char> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<num_put<char> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<num_get<char> >(const locale&);
|
|
|
|
|
|
extern template class numpunct<wchar_t>;
|
|
extern template class numpunct_byname<wchar_t>;
|
|
extern template class num_get<wchar_t>;
|
|
extern template class num_put<wchar_t>;
|
|
extern template class ctype_byname<wchar_t>;
|
|
|
|
extern template
|
|
const ctype<wchar_t>&
|
|
use_facet<ctype<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
const numpunct<wchar_t>&
|
|
use_facet<numpunct<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
const num_put<wchar_t>&
|
|
use_facet<num_put<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
const num_get<wchar_t>&
|
|
use_facet<num_get<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<ctype<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<numpunct<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<num_put<wchar_t> >(const locale&);
|
|
|
|
extern template
|
|
bool
|
|
has_facet<num_get<wchar_t> >(const locale&);
|
|
|
|
|
|
|
|
|
|
}
|
|
# 2609 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
|
|
# 38 "/usr/include/c++/4.8.2/bits/basic_ios.h" 2 3
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _Facet>
|
|
inline const _Facet&
|
|
__check_facet(const _Facet* __f)
|
|
{
|
|
if (!__f)
|
|
__throw_bad_cast();
|
|
return *__f;
|
|
}
|
|
# 65 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class basic_ios : public ios_base
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef ctype<_CharT> __ctype_type;
|
|
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
|
|
__num_put_type;
|
|
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
|
|
__num_get_type;
|
|
|
|
|
|
|
|
protected:
|
|
basic_ostream<_CharT, _Traits>* _M_tie;
|
|
mutable char_type _M_fill;
|
|
mutable bool _M_fill_init;
|
|
basic_streambuf<_CharT, _Traits>* _M_streambuf;
|
|
|
|
|
|
const __ctype_type* _M_ctype;
|
|
|
|
const __num_put_type* _M_num_put;
|
|
|
|
const __num_get_type* _M_num_get;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
operator void*() const
|
|
{ return this->fail() ? 0 : const_cast<basic_ios*>(this); }
|
|
|
|
bool
|
|
operator!() const
|
|
{ return this->fail(); }
|
|
# 130 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
iostate
|
|
rdstate() const
|
|
{ return _M_streambuf_state; }
|
|
# 141 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
void
|
|
clear(iostate __state = goodbit);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
setstate(iostate __state)
|
|
{ this->clear(this->rdstate() | __state); }
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_setstate(iostate __state)
|
|
{
|
|
|
|
|
|
_M_streambuf_state |= __state;
|
|
if (this->exceptions() & __state)
|
|
throw;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
good() const
|
|
{ return this->rdstate() == 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
eof() const
|
|
{ return (this->rdstate() & eofbit) != 0; }
|
|
# 194 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
bool
|
|
fail() const
|
|
{ return (this->rdstate() & (badbit | failbit)) != 0; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
bad() const
|
|
{ return (this->rdstate() & badbit) != 0; }
|
|
# 215 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
iostate
|
|
exceptions() const
|
|
{ return _M_exception; }
|
|
# 250 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
void
|
|
exceptions(iostate __except)
|
|
{
|
|
_M_exception = __except;
|
|
this->clear(_M_streambuf_state);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
|
|
: ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
|
|
_M_ctype(0), _M_num_put(0), _M_num_get(0)
|
|
{ this->init(__sb); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual
|
|
~basic_ios() { }
|
|
# 288 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
basic_ostream<_CharT, _Traits>*
|
|
tie() const
|
|
{ return _M_tie; }
|
|
# 300 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
basic_ostream<_CharT, _Traits>*
|
|
tie(basic_ostream<_CharT, _Traits>* __tiestr)
|
|
{
|
|
basic_ostream<_CharT, _Traits>* __old = _M_tie;
|
|
_M_tie = __tiestr;
|
|
return __old;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_streambuf<_CharT, _Traits>*
|
|
rdbuf() const
|
|
{ return _M_streambuf; }
|
|
# 340 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
basic_streambuf<_CharT, _Traits>*
|
|
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
|
|
# 354 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
basic_ios&
|
|
copyfmt(const basic_ios& __rhs);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
char_type
|
|
fill() const
|
|
{
|
|
if (!_M_fill_init)
|
|
{
|
|
_M_fill = this->widen(' ');
|
|
_M_fill_init = true;
|
|
}
|
|
return _M_fill;
|
|
}
|
|
# 383 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
char_type
|
|
fill(char_type __ch)
|
|
{
|
|
char_type __old = this->fill();
|
|
_M_fill = __ch;
|
|
return __old;
|
|
}
|
|
# 403 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
locale
|
|
imbue(const locale& __loc);
|
|
# 423 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
char
|
|
narrow(char_type __c, char __dfault) const
|
|
{ return __check_facet(_M_ctype).narrow(__c, __dfault); }
|
|
# 442 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
|
|
char_type
|
|
widen(char __c) const
|
|
{ return __check_facet(_M_ctype).widen(__c); }
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
basic_ios()
|
|
: ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
|
|
_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
init(basic_streambuf<_CharT, _Traits>* __sb);
|
|
|
|
void
|
|
_M_cache_locale(const locale& __loc);
|
|
};
|
|
|
|
|
|
}
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 1 3
|
|
# 33 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
|
|
|
|
# 34 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
void
|
|
basic_ios<_CharT, _Traits>::clear(iostate __state)
|
|
{
|
|
if (this->rdbuf())
|
|
_M_streambuf_state = __state;
|
|
else
|
|
_M_streambuf_state = __state | badbit;
|
|
if (this->exceptions() & this->rdstate())
|
|
__throw_ios_failure(("basic_ios::clear"));
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_streambuf<_CharT, _Traits>*
|
|
basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
|
|
{
|
|
basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
|
|
_M_streambuf = __sb;
|
|
this->clear();
|
|
return __old;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ios<_CharT, _Traits>&
|
|
basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
|
|
{
|
|
|
|
|
|
if (this != &__rhs)
|
|
{
|
|
|
|
|
|
|
|
|
|
_Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
|
|
_M_local_word : new _Words[__rhs._M_word_size];
|
|
|
|
|
|
_Callback_list* __cb = __rhs._M_callbacks;
|
|
if (__cb)
|
|
__cb->_M_add_reference();
|
|
_M_call_callbacks(erase_event);
|
|
if (_M_word != _M_local_word)
|
|
{
|
|
delete [] _M_word;
|
|
_M_word = 0;
|
|
}
|
|
_M_dispose_callbacks();
|
|
|
|
|
|
_M_callbacks = __cb;
|
|
for (int __i = 0; __i < __rhs._M_word_size; ++__i)
|
|
__words[__i] = __rhs._M_word[__i];
|
|
_M_word = __words;
|
|
_M_word_size = __rhs._M_word_size;
|
|
|
|
this->flags(__rhs.flags());
|
|
this->width(__rhs.width());
|
|
this->precision(__rhs.precision());
|
|
this->tie(__rhs.tie());
|
|
this->fill(__rhs.fill());
|
|
_M_ios_locale = __rhs.getloc();
|
|
_M_cache_locale(_M_ios_locale);
|
|
|
|
_M_call_callbacks(copyfmt_event);
|
|
|
|
|
|
this->exceptions(__rhs.exceptions());
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
locale
|
|
basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
|
|
{
|
|
locale __old(this->getloc());
|
|
ios_base::imbue(__loc);
|
|
_M_cache_locale(__loc);
|
|
if (this->rdbuf() != 0)
|
|
this->rdbuf()->pubimbue(__loc);
|
|
return __old;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
void
|
|
basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
|
|
{
|
|
|
|
ios_base::_M_init();
|
|
|
|
|
|
_M_cache_locale(_M_ios_locale);
|
|
# 146 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
|
|
_M_fill = _CharT();
|
|
_M_fill_init = false;
|
|
|
|
_M_tie = 0;
|
|
_M_exception = goodbit;
|
|
_M_streambuf = __sb;
|
|
_M_streambuf_state = __sb ? goodbit : badbit;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
void
|
|
basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
|
|
{
|
|
if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
|
|
_M_ctype = &use_facet<__ctype_type>(__loc);
|
|
else
|
|
_M_ctype = 0;
|
|
|
|
if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
|
|
_M_num_put = &use_facet<__num_put_type>(__loc);
|
|
else
|
|
_M_num_put = 0;
|
|
|
|
if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
|
|
_M_num_get = &use_facet<__num_get_type>(__loc);
|
|
else
|
|
_M_num_get = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class basic_ios<char>;
|
|
|
|
|
|
extern template class basic_ios<wchar_t>;
|
|
|
|
|
|
|
|
|
|
}
|
|
# 476 "/usr/include/c++/4.8.2/bits/basic_ios.h" 2 3
|
|
# 45 "/usr/include/c++/4.8.2/ios" 2 3
|
|
# 39 "/usr/include/c++/4.8.2/ostream" 2 3
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 57 "/usr/include/c++/4.8.2/ostream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
|
|
{
|
|
public:
|
|
|
|
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;
|
|
|
|
|
|
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;
|
|
# 83 "/usr/include/c++/4.8.2/ostream" 3
|
|
explicit
|
|
basic_ostream(__streambuf_type* __sb)
|
|
{ this->init(__sb); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual
|
|
~basic_ostream() { }
|
|
|
|
|
|
class sentry;
|
|
friend class sentry;
|
|
# 107 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
operator<<(__ostream_type& (*__pf)(__ostream_type&))
|
|
{
|
|
|
|
|
|
|
|
return __pf(*this);
|
|
}
|
|
|
|
__ostream_type&
|
|
operator<<(__ios_type& (*__pf)(__ios_type&))
|
|
{
|
|
|
|
|
|
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
__ostream_type&
|
|
operator<<(ios_base& (*__pf) (ios_base&))
|
|
{
|
|
|
|
|
|
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
# 165 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
operator<<(long __n)
|
|
{ return _M_insert(__n); }
|
|
|
|
__ostream_type&
|
|
operator<<(unsigned long __n)
|
|
{ return _M_insert(__n); }
|
|
|
|
__ostream_type&
|
|
operator<<(bool __n)
|
|
{ return _M_insert(__n); }
|
|
|
|
__ostream_type&
|
|
operator<<(short __n);
|
|
|
|
__ostream_type&
|
|
operator<<(unsigned short __n)
|
|
{
|
|
|
|
|
|
return _M_insert(static_cast<unsigned long>(__n));
|
|
}
|
|
|
|
__ostream_type&
|
|
operator<<(int __n);
|
|
|
|
__ostream_type&
|
|
operator<<(unsigned int __n)
|
|
{
|
|
|
|
|
|
return _M_insert(static_cast<unsigned long>(__n));
|
|
}
|
|
|
|
|
|
__ostream_type&
|
|
operator<<(long long __n)
|
|
{ return _M_insert(__n); }
|
|
|
|
__ostream_type&
|
|
operator<<(unsigned long long __n)
|
|
{ return _M_insert(__n); }
|
|
# 219 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
operator<<(double __f)
|
|
{ return _M_insert(__f); }
|
|
|
|
__ostream_type&
|
|
operator<<(float __f)
|
|
{
|
|
|
|
|
|
return _M_insert(static_cast<double>(__f));
|
|
}
|
|
|
|
__ostream_type&
|
|
operator<<(long double __f)
|
|
{ return _M_insert(__f); }
|
|
# 244 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
operator<<(const void* __p)
|
|
{ return _M_insert(__p); }
|
|
# 269 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
operator<<(__streambuf_type* __sb);
|
|
# 302 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
put(char_type __c);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_write(const char_type* __s, streamsize __n)
|
|
{
|
|
const streamsize __put = this->rdbuf()->sputn(__s, __n);
|
|
if (__put != __n)
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
# 334 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
write(const char_type* __s, streamsize __n);
|
|
# 347 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
flush();
|
|
# 357 "/usr/include/c++/4.8.2/ostream" 3
|
|
pos_type
|
|
tellp();
|
|
# 368 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
seekp(pos_type);
|
|
# 380 "/usr/include/c++/4.8.2/ostream" 3
|
|
__ostream_type&
|
|
seekp(off_type, ios_base::seekdir);
|
|
|
|
protected:
|
|
basic_ostream()
|
|
{ this->init(0); }
|
|
|
|
template<typename _ValueT>
|
|
__ostream_type&
|
|
_M_insert(_ValueT __v);
|
|
};
|
|
# 399 "/usr/include/c++/4.8.2/ostream" 3
|
|
template <typename _CharT, typename _Traits>
|
|
class basic_ostream<_CharT, _Traits>::sentry
|
|
{
|
|
|
|
bool _M_ok;
|
|
basic_ostream<_CharT, _Traits>& _M_os;
|
|
|
|
public:
|
|
# 418 "/usr/include/c++/4.8.2/ostream" 3
|
|
explicit
|
|
sentry(basic_ostream<_CharT, _Traits>& __os);
|
|
# 428 "/usr/include/c++/4.8.2/ostream" 3
|
|
~sentry()
|
|
{
|
|
|
|
if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
|
|
{
|
|
|
|
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
|
|
_M_os.setstate(ios_base::badbit);
|
|
}
|
|
}
|
|
# 449 "/usr/include/c++/4.8.2/ostream" 3
|
|
operator bool() const
|
|
{ return _M_ok; }
|
|
};
|
|
# 469 "/usr/include/c++/4.8.2/ostream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
|
|
{ return __ostream_insert(__out, &__c, 1); }
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
|
|
{ return (__out << __out.widen(__c)); }
|
|
|
|
|
|
template <class _Traits>
|
|
inline basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __out, char __c)
|
|
{ return __ostream_insert(__out, &__c, 1); }
|
|
|
|
|
|
template<class _Traits>
|
|
inline basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
|
|
{ return (__out << static_cast<char>(__c)); }
|
|
|
|
template<class _Traits>
|
|
inline basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
|
|
{ return (__out << static_cast<char>(__c)); }
|
|
# 511 "/usr/include/c++/4.8.2/ostream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
|
|
{
|
|
if (!__s)
|
|
__out.setstate(ios_base::badbit);
|
|
else
|
|
__ostream_insert(__out, __s,
|
|
static_cast<streamsize>(_Traits::length(__s)));
|
|
return __out;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits> &
|
|
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
|
|
|
|
|
|
template<class _Traits>
|
|
inline basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
|
|
{
|
|
if (!__s)
|
|
__out.setstate(ios_base::badbit);
|
|
else
|
|
__ostream_insert(__out, __s,
|
|
static_cast<streamsize>(_Traits::length(__s)));
|
|
return __out;
|
|
}
|
|
|
|
|
|
template<class _Traits>
|
|
inline basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
|
|
{ return (__out << reinterpret_cast<const char*>(__s)); }
|
|
|
|
template<class _Traits>
|
|
inline basic_ostream<char, _Traits> &
|
|
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
|
|
{ return (__out << reinterpret_cast<const char*>(__s)); }
|
|
# 562 "/usr/include/c++/4.8.2/ostream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
endl(basic_ostream<_CharT, _Traits>& __os)
|
|
{ return flush(__os.put(__os.widen('\n'))); }
|
|
# 574 "/usr/include/c++/4.8.2/ostream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
ends(basic_ostream<_CharT, _Traits>& __os)
|
|
{ return __os.put(_CharT()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
inline basic_ostream<_CharT, _Traits>&
|
|
flush(basic_ostream<_CharT, _Traits>& __os)
|
|
{ return __os.flush(); }
|
|
# 609 "/usr/include/c++/4.8.2/ostream" 3
|
|
|
|
}
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/ostream.tcc" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/ostream.tcc" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/ostream.tcc" 3
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>::sentry::
|
|
sentry(basic_ostream<_CharT, _Traits>& __os)
|
|
: _M_ok(false), _M_os(__os)
|
|
{
|
|
|
|
if (__os.tie() && __os.good())
|
|
__os.tie()->flush();
|
|
|
|
if (__os.good())
|
|
_M_ok = true;
|
|
else
|
|
__os.setstate(ios_base::failbit);
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
template<typename _ValueT>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
_M_insert(_ValueT __v)
|
|
{
|
|
sentry __cerb(*this);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const __num_put_type& __np = __check_facet(this->_M_num_put);
|
|
if (__np.put(*this, *this, this->fill(), __v).failed())
|
|
__err |= ios_base::badbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
operator<<(short __n)
|
|
{
|
|
|
|
|
|
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
|
|
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
|
|
return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
|
|
else
|
|
return _M_insert(static_cast<long>(__n));
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
operator<<(int __n)
|
|
{
|
|
|
|
|
|
const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
|
|
if (__fmt == ios_base::oct || __fmt == ios_base::hex)
|
|
return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
|
|
else
|
|
return _M_insert(static_cast<long>(__n));
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
operator<<(__streambuf_type* __sbin)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this);
|
|
if (__cerb && __sbin)
|
|
{
|
|
try
|
|
{
|
|
if (!__copy_streambufs(__sbin, this->rdbuf()))
|
|
__err |= ios_base::failbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::failbit); }
|
|
}
|
|
else if (!__sbin)
|
|
__err |= ios_base::badbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
put(char_type __c)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
sentry __cerb(*this);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const int_type __put = this->rdbuf()->sputc(__c);
|
|
if (traits_type::eq_int_type(__put, traits_type::eof()))
|
|
__err |= ios_base::badbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
write(const _CharT* __s, streamsize __n)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
sentry __cerb(*this);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{ _M_write(__s, __n); }
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
flush()
|
|
{
|
|
|
|
|
|
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
|
|
__err |= ios_base::badbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
typename basic_ostream<_CharT, _Traits>::pos_type
|
|
basic_ostream<_CharT, _Traits>::
|
|
tellp()
|
|
{
|
|
pos_type __ret = pos_type(-1);
|
|
try
|
|
{
|
|
if (!this->fail())
|
|
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
seekp(pos_type __pos)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
if (!this->fail())
|
|
{
|
|
|
|
|
|
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
|
|
ios_base::out);
|
|
|
|
|
|
if (__p == pos_type(off_type(-1)))
|
|
__err |= ios_base::failbit;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::
|
|
seekp(off_type __off, ios_base::seekdir __dir)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
if (!this->fail())
|
|
{
|
|
|
|
|
|
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
|
|
ios_base::out);
|
|
|
|
|
|
if (__p == pos_type(off_type(-1)))
|
|
__err |= ios_base::failbit;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
|
|
{
|
|
if (!__s)
|
|
__out.setstate(ios_base::badbit);
|
|
else
|
|
{
|
|
|
|
|
|
const size_t __clen = char_traits<char>::length(__s);
|
|
try
|
|
{
|
|
struct __ptr_guard
|
|
{
|
|
_CharT *__p;
|
|
__ptr_guard (_CharT *__ip): __p(__ip) { }
|
|
~__ptr_guard() { delete[] __p; }
|
|
_CharT* __get() { return __p; }
|
|
} __pg (new _CharT[__clen]);
|
|
|
|
_CharT *__ws = __pg.__get();
|
|
for (size_t __i = 0; __i < __clen; ++__i)
|
|
__ws[__i] = __out.widen(__s[__i]);
|
|
__ostream_insert(__out, __ws, __clen);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__out._M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ __out._M_setstate(ios_base::badbit); }
|
|
}
|
|
return __out;
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class basic_ostream<char>;
|
|
extern template ostream& endl(ostream&);
|
|
extern template ostream& ends(ostream&);
|
|
extern template ostream& flush(ostream&);
|
|
extern template ostream& operator<<(ostream&, char);
|
|
extern template ostream& operator<<(ostream&, unsigned char);
|
|
extern template ostream& operator<<(ostream&, signed char);
|
|
extern template ostream& operator<<(ostream&, const char*);
|
|
extern template ostream& operator<<(ostream&, const unsigned char*);
|
|
extern template ostream& operator<<(ostream&, const signed char*);
|
|
|
|
extern template ostream& ostream::_M_insert(long);
|
|
extern template ostream& ostream::_M_insert(unsigned long);
|
|
extern template ostream& ostream::_M_insert(bool);
|
|
|
|
extern template ostream& ostream::_M_insert(long long);
|
|
extern template ostream& ostream::_M_insert(unsigned long long);
|
|
|
|
extern template ostream& ostream::_M_insert(double);
|
|
extern template ostream& ostream::_M_insert(long double);
|
|
extern template ostream& ostream::_M_insert(const void*);
|
|
|
|
|
|
extern template class basic_ostream<wchar_t>;
|
|
extern template wostream& endl(wostream&);
|
|
extern template wostream& ends(wostream&);
|
|
extern template wostream& flush(wostream&);
|
|
extern template wostream& operator<<(wostream&, wchar_t);
|
|
extern template wostream& operator<<(wostream&, char);
|
|
extern template wostream& operator<<(wostream&, const wchar_t*);
|
|
extern template wostream& operator<<(wostream&, const char*);
|
|
|
|
extern template wostream& wostream::_M_insert(long);
|
|
extern template wostream& wostream::_M_insert(unsigned long);
|
|
extern template wostream& wostream::_M_insert(bool);
|
|
|
|
extern template wostream& wostream::_M_insert(long long);
|
|
extern template wostream& wostream::_M_insert(unsigned long long);
|
|
|
|
extern template wostream& wostream::_M_insert(double);
|
|
extern template wostream& wostream::_M_insert(long double);
|
|
extern template wostream& wostream::_M_insert(const void*);
|
|
|
|
|
|
|
|
|
|
}
|
|
# 613 "/usr/include/c++/4.8.2/ostream" 2 3
|
|
# 40 "/usr/include/c++/4.8.2/iostream" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/istream" 1 3
|
|
# 36 "/usr/include/c++/4.8.2/istream" 3
|
|
|
|
# 37 "/usr/include/c++/4.8.2/istream" 3
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 57 "/usr/include/c++/4.8.2/istream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class basic_istream : virtual public basic_ios<_CharT, _Traits>
|
|
{
|
|
public:
|
|
|
|
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;
|
|
|
|
|
|
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
|
|
typedef basic_ios<_CharT, _Traits> __ios_type;
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
|
|
__num_get_type;
|
|
typedef ctype<_CharT> __ctype_type;
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
streamsize _M_gcount;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
basic_istream(__streambuf_type* __sb)
|
|
: _M_gcount(streamsize(0))
|
|
{ this->init(__sb); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual
|
|
~basic_istream()
|
|
{ _M_gcount = streamsize(0); }
|
|
|
|
|
|
class sentry;
|
|
friend class sentry;
|
|
# 119 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
operator>>(__istream_type& (*__pf)(__istream_type&))
|
|
{ return __pf(*this); }
|
|
|
|
__istream_type&
|
|
operator>>(__ios_type& (*__pf)(__ios_type&))
|
|
{
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
__istream_type&
|
|
operator>>(ios_base& (*__pf)(ios_base&))
|
|
{
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
# 167 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
operator>>(bool& __n)
|
|
{ return _M_extract(__n); }
|
|
|
|
__istream_type&
|
|
operator>>(short& __n);
|
|
|
|
__istream_type&
|
|
operator>>(unsigned short& __n)
|
|
{ return _M_extract(__n); }
|
|
|
|
__istream_type&
|
|
operator>>(int& __n);
|
|
|
|
__istream_type&
|
|
operator>>(unsigned int& __n)
|
|
{ return _M_extract(__n); }
|
|
|
|
__istream_type&
|
|
operator>>(long& __n)
|
|
{ return _M_extract(__n); }
|
|
|
|
__istream_type&
|
|
operator>>(unsigned long& __n)
|
|
{ return _M_extract(__n); }
|
|
|
|
|
|
__istream_type&
|
|
operator>>(long long& __n)
|
|
{ return _M_extract(__n); }
|
|
|
|
__istream_type&
|
|
operator>>(unsigned long long& __n)
|
|
{ return _M_extract(__n); }
|
|
# 213 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
operator>>(float& __f)
|
|
{ return _M_extract(__f); }
|
|
|
|
__istream_type&
|
|
operator>>(double& __f)
|
|
{ return _M_extract(__f); }
|
|
|
|
__istream_type&
|
|
operator>>(long double& __f)
|
|
{ return _M_extract(__f); }
|
|
# 234 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
operator>>(void*& __p)
|
|
{ return _M_extract(__p); }
|
|
# 258 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
operator>>(__streambuf_type* __sb);
|
|
# 268 "/usr/include/c++/4.8.2/istream" 3
|
|
streamsize
|
|
gcount() const
|
|
{ return _M_gcount; }
|
|
# 301 "/usr/include/c++/4.8.2/istream" 3
|
|
int_type
|
|
get();
|
|
# 315 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
get(char_type& __c);
|
|
# 342 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
get(char_type* __s, streamsize __n, char_type __delim);
|
|
# 353 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
get(char_type* __s, streamsize __n)
|
|
{ return this->get(__s, __n, this->widen('\n')); }
|
|
# 376 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
get(__streambuf_type& __sb, char_type __delim);
|
|
# 386 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
get(__streambuf_type& __sb)
|
|
{ return this->get(__sb, this->widen('\n')); }
|
|
# 415 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
getline(char_type* __s, streamsize __n, char_type __delim);
|
|
# 426 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
getline(char_type* __s, streamsize __n)
|
|
{ return this->getline(__s, __n, this->widen('\n')); }
|
|
# 450 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
ignore(streamsize __n, int_type __delim);
|
|
|
|
__istream_type&
|
|
ignore(streamsize __n);
|
|
|
|
__istream_type&
|
|
ignore();
|
|
# 467 "/usr/include/c++/4.8.2/istream" 3
|
|
int_type
|
|
peek();
|
|
# 485 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
read(char_type* __s, streamsize __n);
|
|
# 504 "/usr/include/c++/4.8.2/istream" 3
|
|
streamsize
|
|
readsome(char_type* __s, streamsize __n);
|
|
# 521 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
putback(char_type __c);
|
|
# 537 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
unget();
|
|
# 555 "/usr/include/c++/4.8.2/istream" 3
|
|
int
|
|
sync();
|
|
# 570 "/usr/include/c++/4.8.2/istream" 3
|
|
pos_type
|
|
tellg();
|
|
# 585 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
seekg(pos_type);
|
|
# 601 "/usr/include/c++/4.8.2/istream" 3
|
|
__istream_type&
|
|
seekg(off_type, ios_base::seekdir);
|
|
|
|
|
|
protected:
|
|
basic_istream()
|
|
: _M_gcount(streamsize(0))
|
|
{ this->init(0); }
|
|
|
|
template<typename _ValueT>
|
|
__istream_type&
|
|
_M_extract(_ValueT& __v);
|
|
};
|
|
|
|
|
|
template<>
|
|
basic_istream<char>&
|
|
basic_istream<char>::
|
|
getline(char_type* __s, streamsize __n, char_type __delim);
|
|
|
|
template<>
|
|
basic_istream<char>&
|
|
basic_istream<char>::
|
|
ignore(streamsize __n);
|
|
|
|
template<>
|
|
basic_istream<char>&
|
|
basic_istream<char>::
|
|
ignore(streamsize __n, int_type __delim);
|
|
|
|
|
|
template<>
|
|
basic_istream<wchar_t>&
|
|
basic_istream<wchar_t>::
|
|
getline(char_type* __s, streamsize __n, char_type __delim);
|
|
|
|
template<>
|
|
basic_istream<wchar_t>&
|
|
basic_istream<wchar_t>::
|
|
ignore(streamsize __n);
|
|
|
|
template<>
|
|
basic_istream<wchar_t>&
|
|
basic_istream<wchar_t>::
|
|
ignore(streamsize __n, int_type __delim);
|
|
# 656 "/usr/include/c++/4.8.2/istream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class basic_istream<_CharT, _Traits>::sentry
|
|
{
|
|
|
|
bool _M_ok;
|
|
|
|
public:
|
|
|
|
typedef _Traits traits_type;
|
|
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef typename __istream_type::__ctype_type __ctype_type;
|
|
typedef typename _Traits::int_type __int_type;
|
|
# 692 "/usr/include/c++/4.8.2/istream" 3
|
|
explicit
|
|
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
|
|
# 705 "/usr/include/c++/4.8.2/istream" 3
|
|
operator bool() const
|
|
{ return _M_ok; }
|
|
};
|
|
# 721 "/usr/include/c++/4.8.2/istream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
|
|
|
|
template<class _Traits>
|
|
inline basic_istream<char, _Traits>&
|
|
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
|
|
{ return (__in >> reinterpret_cast<char&>(__c)); }
|
|
|
|
template<class _Traits>
|
|
inline basic_istream<char, _Traits>&
|
|
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
|
|
{ return (__in >> reinterpret_cast<char&>(__c)); }
|
|
# 763 "/usr/include/c++/4.8.2/istream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
|
|
|
|
|
|
template<>
|
|
basic_istream<char>&
|
|
operator>>(basic_istream<char>& __in, char* __s);
|
|
|
|
template<class _Traits>
|
|
inline basic_istream<char, _Traits>&
|
|
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
|
|
{ return (__in >> reinterpret_cast<char*>(__s)); }
|
|
|
|
template<class _Traits>
|
|
inline basic_istream<char, _Traits>&
|
|
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
|
|
{ return (__in >> reinterpret_cast<char*>(__s)); }
|
|
# 794 "/usr/include/c++/4.8.2/istream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
class basic_iostream
|
|
: public basic_istream<_CharT, _Traits>,
|
|
public basic_ostream<_CharT, _Traits>
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef basic_ostream<_CharT, _Traits> __ostream_type;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
|
|
: __istream_type(__sb), __ostream_type(__sb) { }
|
|
|
|
|
|
|
|
|
|
virtual
|
|
~basic_iostream() { }
|
|
|
|
protected:
|
|
basic_iostream()
|
|
: __istream_type(), __ostream_type() { }
|
|
};
|
|
# 854 "/usr/include/c++/4.8.2/istream" 3
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
ws(basic_istream<_CharT, _Traits>& __is);
|
|
# 879 "/usr/include/c++/4.8.2/istream" 3
|
|
|
|
}
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/istream.tcc" 1 3
|
|
# 37 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
|
|
|
|
# 38 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>::sentry::
|
|
sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
if (__in.good())
|
|
try
|
|
{
|
|
if (__in.tie())
|
|
__in.tie()->flush();
|
|
if (!__noskip && bool(__in.flags() & ios_base::skipws))
|
|
{
|
|
const __int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = __in.rdbuf();
|
|
__int_type __c = __sb->sgetc();
|
|
|
|
const __ctype_type& __ct = __check_facet(__in._M_ctype);
|
|
while (!traits_type::eq_int_type(__c, __eof)
|
|
&& __ct.is(ctype_base::space,
|
|
traits_type::to_char_type(__c)))
|
|
__c = __sb->snextc();
|
|
|
|
|
|
|
|
|
|
if (traits_type::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__in._M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ __in._M_setstate(ios_base::badbit); }
|
|
|
|
if (__in.good() && __err == ios_base::goodbit)
|
|
_M_ok = true;
|
|
else
|
|
{
|
|
__err |= ios_base::failbit;
|
|
__in.setstate(__err);
|
|
}
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
template<typename _ValueT>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
_M_extract(_ValueT& __v)
|
|
{
|
|
sentry __cerb(*this, false);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const __num_get_type& __ng = __check_facet(this->_M_num_get);
|
|
__ng.get(*this, 0, *this, __err, __v);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
operator>>(short& __n)
|
|
{
|
|
|
|
|
|
sentry __cerb(*this, false);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
long __l;
|
|
const __num_get_type& __ng = __check_facet(this->_M_num_get);
|
|
__ng.get(*this, 0, *this, __err, __l);
|
|
|
|
|
|
|
|
if (__l < __gnu_cxx::__numeric_traits<short>::__min)
|
|
{
|
|
__err |= ios_base::failbit;
|
|
__n = __gnu_cxx::__numeric_traits<short>::__min;
|
|
}
|
|
else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
|
|
{
|
|
__err |= ios_base::failbit;
|
|
__n = __gnu_cxx::__numeric_traits<short>::__max;
|
|
}
|
|
else
|
|
__n = short(__l);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
operator>>(int& __n)
|
|
{
|
|
|
|
|
|
sentry __cerb(*this, false);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
long __l;
|
|
const __num_get_type& __ng = __check_facet(this->_M_num_get);
|
|
__ng.get(*this, 0, *this, __err, __l);
|
|
|
|
|
|
|
|
if (__l < __gnu_cxx::__numeric_traits<int>::__min)
|
|
{
|
|
__err |= ios_base::failbit;
|
|
__n = __gnu_cxx::__numeric_traits<int>::__min;
|
|
}
|
|
else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
|
|
{
|
|
__err |= ios_base::failbit;
|
|
__n = __gnu_cxx::__numeric_traits<int>::__max;
|
|
}
|
|
else
|
|
__n = int(__l);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
operator>>(__streambuf_type* __sbout)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this, false);
|
|
if (__cerb && __sbout)
|
|
{
|
|
try
|
|
{
|
|
bool __ineof;
|
|
if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
|
|
__err |= ios_base::failbit;
|
|
if (__ineof)
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::failbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::failbit); }
|
|
}
|
|
else if (!__sbout)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
typename basic_istream<_CharT, _Traits>::int_type
|
|
basic_istream<_CharT, _Traits>::
|
|
get(void)
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
int_type __c = __eof;
|
|
_M_gcount = 0;
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
__c = this->rdbuf()->sbumpc();
|
|
|
|
if (!traits_type::eq_int_type(__c, __eof))
|
|
_M_gcount = 1;
|
|
else
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
if (!_M_gcount)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return __c;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
get(char_type& __c)
|
|
{
|
|
_M_gcount = 0;
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
const int_type __cb = this->rdbuf()->sbumpc();
|
|
|
|
if (!traits_type::eq_int_type(__cb, traits_type::eof()))
|
|
{
|
|
_M_gcount = 1;
|
|
__c = traits_type::to_char_type(__cb);
|
|
}
|
|
else
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
if (!_M_gcount)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
get(char_type* __s, streamsize __n, char_type __delim)
|
|
{
|
|
_M_gcount = 0;
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
const int_type __idelim = traits_type::to_int_type(__delim);
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
int_type __c = __sb->sgetc();
|
|
|
|
while (_M_gcount + 1 < __n
|
|
&& !traits_type::eq_int_type(__c, __eof)
|
|
&& !traits_type::eq_int_type(__c, __idelim))
|
|
{
|
|
*__s++ = traits_type::to_char_type(__c);
|
|
++_M_gcount;
|
|
__c = __sb->snextc();
|
|
}
|
|
if (traits_type::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
|
|
|
|
if (__n > 0)
|
|
*__s = char_type();
|
|
if (!_M_gcount)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
get(__streambuf_type& __sb, char_type __delim)
|
|
{
|
|
_M_gcount = 0;
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
const int_type __idelim = traits_type::to_int_type(__delim);
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __this_sb = this->rdbuf();
|
|
int_type __c = __this_sb->sgetc();
|
|
char_type __c2 = traits_type::to_char_type(__c);
|
|
|
|
while (!traits_type::eq_int_type(__c, __eof)
|
|
&& !traits_type::eq_int_type(__c, __idelim)
|
|
&& !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
|
|
{
|
|
++_M_gcount;
|
|
__c = __this_sb->snextc();
|
|
__c2 = traits_type::to_char_type(__c);
|
|
}
|
|
if (traits_type::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
if (!_M_gcount)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
getline(char_type* __s, streamsize __n, char_type __delim)
|
|
{
|
|
_M_gcount = 0;
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
const int_type __idelim = traits_type::to_int_type(__delim);
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
int_type __c = __sb->sgetc();
|
|
|
|
while (_M_gcount + 1 < __n
|
|
&& !traits_type::eq_int_type(__c, __eof)
|
|
&& !traits_type::eq_int_type(__c, __idelim))
|
|
{
|
|
*__s++ = traits_type::to_char_type(__c);
|
|
__c = __sb->snextc();
|
|
++_M_gcount;
|
|
}
|
|
if (traits_type::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
else
|
|
{
|
|
if (traits_type::eq_int_type(__c, __idelim))
|
|
{
|
|
__sb->sbumpc();
|
|
++_M_gcount;
|
|
}
|
|
else
|
|
__err |= ios_base::failbit;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
|
|
|
|
if (__n > 0)
|
|
*__s = char_type();
|
|
if (!_M_gcount)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
this->setstate(__err);
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
ignore(void)
|
|
{
|
|
_M_gcount = 0;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
|
|
if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
|
|
__err |= ios_base::eofbit;
|
|
else
|
|
_M_gcount = 1;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
ignore(streamsize __n)
|
|
{
|
|
_M_gcount = 0;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb && __n > 0)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
int_type __c = __sb->sgetc();
|
|
# 521 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
|
|
bool __large_ignore = false;
|
|
while (true)
|
|
{
|
|
while (_M_gcount < __n
|
|
&& !traits_type::eq_int_type(__c, __eof))
|
|
{
|
|
++_M_gcount;
|
|
__c = __sb->snextc();
|
|
}
|
|
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
|
|
&& !traits_type::eq_int_type(__c, __eof))
|
|
{
|
|
_M_gcount =
|
|
__gnu_cxx::__numeric_traits<streamsize>::__min;
|
|
__large_ignore = true;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (__large_ignore)
|
|
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
|
|
|
|
if (traits_type::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
ignore(streamsize __n, int_type __delim)
|
|
{
|
|
_M_gcount = 0;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb && __n > 0)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
int_type __c = __sb->sgetc();
|
|
|
|
|
|
bool __large_ignore = false;
|
|
while (true)
|
|
{
|
|
while (_M_gcount < __n
|
|
&& !traits_type::eq_int_type(__c, __eof)
|
|
&& !traits_type::eq_int_type(__c, __delim))
|
|
{
|
|
++_M_gcount;
|
|
__c = __sb->snextc();
|
|
}
|
|
if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
|
|
&& !traits_type::eq_int_type(__c, __eof)
|
|
&& !traits_type::eq_int_type(__c, __delim))
|
|
{
|
|
_M_gcount =
|
|
__gnu_cxx::__numeric_traits<streamsize>::__min;
|
|
__large_ignore = true;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (__large_ignore)
|
|
_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
|
|
|
|
if (traits_type::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
else if (traits_type::eq_int_type(__c, __delim))
|
|
{
|
|
if (_M_gcount
|
|
< __gnu_cxx::__numeric_traits<streamsize>::__max)
|
|
++_M_gcount;
|
|
__sb->sbumpc();
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
typename basic_istream<_CharT, _Traits>::int_type
|
|
basic_istream<_CharT, _Traits>::
|
|
peek(void)
|
|
{
|
|
int_type __c = traits_type::eof();
|
|
_M_gcount = 0;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
__c = this->rdbuf()->sgetc();
|
|
if (traits_type::eq_int_type(__c, traits_type::eof()))
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return __c;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
read(char_type* __s, streamsize __n)
|
|
{
|
|
_M_gcount = 0;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
_M_gcount = this->rdbuf()->sgetn(__s, __n);
|
|
if (_M_gcount != __n)
|
|
__err |= (ios_base::eofbit | ios_base::failbit);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
streamsize
|
|
basic_istream<_CharT, _Traits>::
|
|
readsome(char_type* __s, streamsize __n)
|
|
{
|
|
_M_gcount = 0;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
|
|
const streamsize __num = this->rdbuf()->in_avail();
|
|
if (__num > 0)
|
|
_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
|
|
else if (__num == -1)
|
|
__err |= ios_base::eofbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return _M_gcount;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
putback(char_type __c)
|
|
{
|
|
|
|
|
|
_M_gcount = 0;
|
|
|
|
this->clear(this->rdstate() & ~ios_base::eofbit);
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
if (!__sb
|
|
|| traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
|
|
__err |= ios_base::badbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
unget(void)
|
|
{
|
|
|
|
|
|
_M_gcount = 0;
|
|
|
|
this->clear(this->rdstate() & ~ios_base::eofbit);
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const int_type __eof = traits_type::eof();
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
if (!__sb
|
|
|| traits_type::eq_int_type(__sb->sungetc(), __eof))
|
|
__err |= ios_base::badbit;
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
int
|
|
basic_istream<_CharT, _Traits>::
|
|
sync(void)
|
|
{
|
|
|
|
|
|
int __ret = -1;
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
__streambuf_type* __sb = this->rdbuf();
|
|
if (__sb)
|
|
{
|
|
if (__sb->pubsync() == -1)
|
|
__err |= ios_base::badbit;
|
|
else
|
|
__ret = 0;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
typename basic_istream<_CharT, _Traits>::pos_type
|
|
basic_istream<_CharT, _Traits>::
|
|
tellg(void)
|
|
{
|
|
|
|
|
|
pos_type __ret = pos_type(-1);
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
if (!this->fail())
|
|
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
|
|
ios_base::in);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
}
|
|
return __ret;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
seekg(pos_type __pos)
|
|
{
|
|
|
|
|
|
|
|
this->clear(this->rdstate() & ~ios_base::eofbit);
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
if (!this->fail())
|
|
{
|
|
|
|
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
|
|
ios_base::in);
|
|
|
|
|
|
if (__p == pos_type(off_type(-1)))
|
|
__err |= ios_base::failbit;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
basic_istream<_CharT, _Traits>::
|
|
seekg(off_type __off, ios_base::seekdir __dir)
|
|
{
|
|
|
|
|
|
|
|
this->clear(this->rdstate() & ~ios_base::eofbit);
|
|
sentry __cerb(*this, true);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
if (!this->fail())
|
|
{
|
|
|
|
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
|
|
ios_base::in);
|
|
|
|
|
|
if (__p == pos_type(off_type(-1)))
|
|
__err |= ios_base::failbit;
|
|
}
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
this->_M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ this->_M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
this->setstate(__err);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
|
|
{
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef typename __istream_type::int_type __int_type;
|
|
|
|
typename __istream_type::sentry __cerb(__in, false);
|
|
if (__cerb)
|
|
{
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
try
|
|
{
|
|
const __int_type __cb = __in.rdbuf()->sbumpc();
|
|
if (!_Traits::eq_int_type(__cb, _Traits::eof()))
|
|
__c = _Traits::to_char_type(__cb);
|
|
else
|
|
__err |= (ios_base::eofbit | ios_base::failbit);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__in._M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ __in._M_setstate(ios_base::badbit); }
|
|
if (__err)
|
|
__in.setstate(__err);
|
|
}
|
|
return __in;
|
|
}
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
|
|
{
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
|
|
typedef typename _Traits::int_type int_type;
|
|
typedef _CharT char_type;
|
|
typedef ctype<_CharT> __ctype_type;
|
|
|
|
streamsize __extracted = 0;
|
|
ios_base::iostate __err = ios_base::goodbit;
|
|
typename __istream_type::sentry __cerb(__in, false);
|
|
if (__cerb)
|
|
{
|
|
try
|
|
{
|
|
|
|
streamsize __num = __in.width();
|
|
if (__num <= 0)
|
|
__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
|
|
|
|
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
|
|
|
|
const int_type __eof = _Traits::eof();
|
|
__streambuf_type* __sb = __in.rdbuf();
|
|
int_type __c = __sb->sgetc();
|
|
|
|
while (__extracted < __num - 1
|
|
&& !_Traits::eq_int_type(__c, __eof)
|
|
&& !__ct.is(ctype_base::space,
|
|
_Traits::to_char_type(__c)))
|
|
{
|
|
*__s++ = _Traits::to_char_type(__c);
|
|
++__extracted;
|
|
__c = __sb->snextc();
|
|
}
|
|
if (_Traits::eq_int_type(__c, __eof))
|
|
__err |= ios_base::eofbit;
|
|
|
|
|
|
|
|
*__s = char_type();
|
|
__in.width(0);
|
|
}
|
|
catch(__cxxabiv1::__forced_unwind&)
|
|
{
|
|
__in._M_setstate(ios_base::badbit);
|
|
throw;
|
|
}
|
|
catch(...)
|
|
{ __in._M_setstate(ios_base::badbit); }
|
|
}
|
|
if (!__extracted)
|
|
__err |= ios_base::failbit;
|
|
if (__err)
|
|
__in.setstate(__err);
|
|
return __in;
|
|
}
|
|
|
|
|
|
template<typename _CharT, typename _Traits>
|
|
basic_istream<_CharT, _Traits>&
|
|
ws(basic_istream<_CharT, _Traits>& __in)
|
|
{
|
|
typedef basic_istream<_CharT, _Traits> __istream_type;
|
|
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
|
|
typedef typename __istream_type::int_type __int_type;
|
|
typedef ctype<_CharT> __ctype_type;
|
|
|
|
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
|
|
const __int_type __eof = _Traits::eof();
|
|
__streambuf_type* __sb = __in.rdbuf();
|
|
__int_type __c = __sb->sgetc();
|
|
|
|
while (!_Traits::eq_int_type(__c, __eof)
|
|
&& __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
|
|
__c = __sb->snextc();
|
|
|
|
if (_Traits::eq_int_type(__c, __eof))
|
|
__in.setstate(ios_base::eofbit);
|
|
return __in;
|
|
}
|
|
|
|
|
|
|
|
|
|
extern template class basic_istream<char>;
|
|
extern template istream& ws(istream&);
|
|
extern template istream& operator>>(istream&, char&);
|
|
extern template istream& operator>>(istream&, char*);
|
|
extern template istream& operator>>(istream&, unsigned char&);
|
|
extern template istream& operator>>(istream&, signed char&);
|
|
extern template istream& operator>>(istream&, unsigned char*);
|
|
extern template istream& operator>>(istream&, signed char*);
|
|
|
|
extern template istream& istream::_M_extract(unsigned short&);
|
|
extern template istream& istream::_M_extract(unsigned int&);
|
|
extern template istream& istream::_M_extract(long&);
|
|
extern template istream& istream::_M_extract(unsigned long&);
|
|
extern template istream& istream::_M_extract(bool&);
|
|
|
|
extern template istream& istream::_M_extract(long long&);
|
|
extern template istream& istream::_M_extract(unsigned long long&);
|
|
|
|
extern template istream& istream::_M_extract(float&);
|
|
extern template istream& istream::_M_extract(double&);
|
|
extern template istream& istream::_M_extract(long double&);
|
|
extern template istream& istream::_M_extract(void*&);
|
|
|
|
extern template class basic_iostream<char>;
|
|
|
|
|
|
extern template class basic_istream<wchar_t>;
|
|
extern template wistream& ws(wistream&);
|
|
extern template wistream& operator>>(wistream&, wchar_t&);
|
|
extern template wistream& operator>>(wistream&, wchar_t*);
|
|
|
|
extern template wistream& wistream::_M_extract(unsigned short&);
|
|
extern template wistream& wistream::_M_extract(unsigned int&);
|
|
extern template wistream& wistream::_M_extract(long&);
|
|
extern template wistream& wistream::_M_extract(unsigned long&);
|
|
extern template wistream& wistream::_M_extract(bool&);
|
|
|
|
extern template wistream& wistream::_M_extract(long long&);
|
|
extern template wistream& wistream::_M_extract(unsigned long long&);
|
|
|
|
extern template wistream& wistream::_M_extract(float&);
|
|
extern template wistream& wistream::_M_extract(double&);
|
|
extern template wistream& wistream::_M_extract(long double&);
|
|
extern template wistream& wistream::_M_extract(void*&);
|
|
|
|
extern template class basic_iostream<wchar_t>;
|
|
|
|
|
|
|
|
|
|
}
|
|
# 883 "/usr/include/c++/4.8.2/istream" 2 3
|
|
# 41 "/usr/include/c++/4.8.2/iostream" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 60 "/usr/include/c++/4.8.2/iostream" 3
|
|
extern istream cin;
|
|
extern ostream cout;
|
|
extern ostream cerr;
|
|
extern ostream clog;
|
|
|
|
|
|
extern wistream wcin;
|
|
extern wostream wcout;
|
|
extern wostream wcerr;
|
|
extern wostream wclog;
|
|
|
|
|
|
|
|
|
|
static ios_base::Init __ioinit;
|
|
|
|
|
|
}
|
|
# 9 "test.cpp" 2
|
|
# 1 "include/CMessageQueue.h" 1
|
|
# 10 "include/CMessageQueue.h"
|
|
# 1 "include/CTypedef.h" 1
|
|
# 10 "include/CTypedef.h"
|
|
# 1 "/usr/include/c++/4.8.2/map" 1 3
|
|
# 58 "/usr/include/c++/4.8.2/map" 3
|
|
|
|
# 59 "/usr/include/c++/4.8.2/map" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_tree.h" 1 3
|
|
# 69 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 89 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
enum _Rb_tree_color { _S_red = false, _S_black = true };
|
|
|
|
struct _Rb_tree_node_base
|
|
{
|
|
typedef _Rb_tree_node_base* _Base_ptr;
|
|
typedef const _Rb_tree_node_base* _Const_Base_ptr;
|
|
|
|
_Rb_tree_color _M_color;
|
|
_Base_ptr _M_parent;
|
|
_Base_ptr _M_left;
|
|
_Base_ptr _M_right;
|
|
|
|
static _Base_ptr
|
|
_S_minimum(_Base_ptr __x)
|
|
{
|
|
while (__x->_M_left != 0) __x = __x->_M_left;
|
|
return __x;
|
|
}
|
|
|
|
static _Const_Base_ptr
|
|
_S_minimum(_Const_Base_ptr __x)
|
|
{
|
|
while (__x->_M_left != 0) __x = __x->_M_left;
|
|
return __x;
|
|
}
|
|
|
|
static _Base_ptr
|
|
_S_maximum(_Base_ptr __x)
|
|
{
|
|
while (__x->_M_right != 0) __x = __x->_M_right;
|
|
return __x;
|
|
}
|
|
|
|
static _Const_Base_ptr
|
|
_S_maximum(_Const_Base_ptr __x)
|
|
{
|
|
while (__x->_M_right != 0) __x = __x->_M_right;
|
|
return __x;
|
|
}
|
|
};
|
|
|
|
template<typename _Val>
|
|
struct _Rb_tree_node : public _Rb_tree_node_base
|
|
{
|
|
typedef _Rb_tree_node<_Val>* _Link_type;
|
|
_Val _M_value_field;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
__attribute__ ((__pure__)) _Rb_tree_node_base*
|
|
_Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
|
|
|
|
__attribute__ ((__pure__)) const _Rb_tree_node_base*
|
|
_Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
|
|
|
|
__attribute__ ((__pure__)) _Rb_tree_node_base*
|
|
_Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
|
|
|
|
__attribute__ ((__pure__)) const _Rb_tree_node_base*
|
|
_Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
|
|
|
|
template<typename _Tp>
|
|
struct _Rb_tree_iterator
|
|
{
|
|
typedef _Tp value_type;
|
|
typedef _Tp& reference;
|
|
typedef _Tp* pointer;
|
|
|
|
typedef bidirectional_iterator_tag iterator_category;
|
|
typedef ptrdiff_t difference_type;
|
|
|
|
typedef _Rb_tree_iterator<_Tp> _Self;
|
|
typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
|
|
typedef _Rb_tree_node<_Tp>* _Link_type;
|
|
|
|
_Rb_tree_iterator()
|
|
: _M_node() { }
|
|
|
|
explicit
|
|
_Rb_tree_iterator(_Link_type __x)
|
|
: _M_node(__x) { }
|
|
|
|
reference
|
|
operator*() const
|
|
{ return static_cast<_Link_type>(_M_node)->_M_value_field; }
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return std::__addressof(static_cast<_Link_type>
|
|
(_M_node)->_M_value_field); }
|
|
|
|
_Self&
|
|
operator++()
|
|
{
|
|
_M_node = _Rb_tree_increment(_M_node);
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator++(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _Rb_tree_increment(_M_node);
|
|
return __tmp;
|
|
}
|
|
|
|
_Self&
|
|
operator--()
|
|
{
|
|
_M_node = _Rb_tree_decrement(_M_node);
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator--(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _Rb_tree_decrement(_M_node);
|
|
return __tmp;
|
|
}
|
|
|
|
bool
|
|
operator==(const _Self& __x) const
|
|
{ return _M_node == __x._M_node; }
|
|
|
|
bool
|
|
operator!=(const _Self& __x) const
|
|
{ return _M_node != __x._M_node; }
|
|
|
|
_Base_ptr _M_node;
|
|
};
|
|
|
|
template<typename _Tp>
|
|
struct _Rb_tree_const_iterator
|
|
{
|
|
typedef _Tp value_type;
|
|
typedef const _Tp& reference;
|
|
typedef const _Tp* pointer;
|
|
|
|
typedef _Rb_tree_iterator<_Tp> iterator;
|
|
|
|
typedef bidirectional_iterator_tag iterator_category;
|
|
typedef ptrdiff_t difference_type;
|
|
|
|
typedef _Rb_tree_const_iterator<_Tp> _Self;
|
|
typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
|
|
typedef const _Rb_tree_node<_Tp>* _Link_type;
|
|
|
|
_Rb_tree_const_iterator()
|
|
: _M_node() { }
|
|
|
|
explicit
|
|
_Rb_tree_const_iterator(_Link_type __x)
|
|
: _M_node(__x) { }
|
|
|
|
_Rb_tree_const_iterator(const iterator& __it)
|
|
: _M_node(__it._M_node) { }
|
|
|
|
iterator
|
|
_M_const_cast() const
|
|
{ return iterator(static_cast<typename iterator::_Link_type>
|
|
(const_cast<typename iterator::_Base_ptr>(_M_node))); }
|
|
|
|
reference
|
|
operator*() const
|
|
{ return static_cast<_Link_type>(_M_node)->_M_value_field; }
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return std::__addressof(static_cast<_Link_type>
|
|
(_M_node)->_M_value_field); }
|
|
|
|
_Self&
|
|
operator++()
|
|
{
|
|
_M_node = _Rb_tree_increment(_M_node);
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator++(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _Rb_tree_increment(_M_node);
|
|
return __tmp;
|
|
}
|
|
|
|
_Self&
|
|
operator--()
|
|
{
|
|
_M_node = _Rb_tree_decrement(_M_node);
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator--(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _Rb_tree_decrement(_M_node);
|
|
return __tmp;
|
|
}
|
|
|
|
bool
|
|
operator==(const _Self& __x) const
|
|
{ return _M_node == __x._M_node; }
|
|
|
|
bool
|
|
operator!=(const _Self& __x) const
|
|
{ return _M_node != __x._M_node; }
|
|
|
|
_Base_ptr _M_node;
|
|
};
|
|
|
|
template<typename _Val>
|
|
inline bool
|
|
operator==(const _Rb_tree_iterator<_Val>& __x,
|
|
const _Rb_tree_const_iterator<_Val>& __y)
|
|
{ return __x._M_node == __y._M_node; }
|
|
|
|
template<typename _Val>
|
|
inline bool
|
|
operator!=(const _Rb_tree_iterator<_Val>& __x,
|
|
const _Rb_tree_const_iterator<_Val>& __y)
|
|
{ return __x._M_node != __y._M_node; }
|
|
|
|
void
|
|
_Rb_tree_insert_and_rebalance(const bool __insert_left,
|
|
_Rb_tree_node_base* __x,
|
|
_Rb_tree_node_base* __p,
|
|
_Rb_tree_node_base& __header) throw ();
|
|
|
|
_Rb_tree_node_base*
|
|
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
|
|
_Rb_tree_node_base& __header) throw ();
|
|
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc = allocator<_Val> >
|
|
class _Rb_tree
|
|
{
|
|
typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
|
|
_Node_allocator;
|
|
|
|
protected:
|
|
typedef _Rb_tree_node_base* _Base_ptr;
|
|
typedef const _Rb_tree_node_base* _Const_Base_ptr;
|
|
|
|
public:
|
|
typedef _Key key_type;
|
|
typedef _Val value_type;
|
|
typedef value_type* pointer;
|
|
typedef const value_type* const_pointer;
|
|
typedef value_type& reference;
|
|
typedef const value_type& const_reference;
|
|
typedef _Rb_tree_node<_Val>* _Link_type;
|
|
typedef const _Rb_tree_node<_Val>* _Const_Link_type;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Alloc allocator_type;
|
|
|
|
_Node_allocator&
|
|
_M_get_Node_allocator()
|
|
{ return *static_cast<_Node_allocator*>(&this->_M_impl); }
|
|
|
|
const _Node_allocator&
|
|
_M_get_Node_allocator() const
|
|
{ return *static_cast<const _Node_allocator*>(&this->_M_impl); }
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_get_Node_allocator()); }
|
|
|
|
protected:
|
|
_Link_type
|
|
_M_get_node()
|
|
{ return _M_impl._Node_allocator::allocate(1); }
|
|
|
|
void
|
|
_M_put_node(_Link_type __p)
|
|
{ _M_impl._Node_allocator::deallocate(__p, 1); }
|
|
|
|
|
|
_Link_type
|
|
_M_create_node(const value_type& __x)
|
|
{
|
|
_Link_type __tmp = _M_get_node();
|
|
try
|
|
{ get_allocator().construct
|
|
(std::__addressof(__tmp->_M_value_field), __x); }
|
|
catch(...)
|
|
{
|
|
_M_put_node(__tmp);
|
|
throw;
|
|
}
|
|
return __tmp;
|
|
}
|
|
|
|
void
|
|
_M_destroy_node(_Link_type __p)
|
|
{
|
|
get_allocator().destroy(std::__addressof(__p->_M_value_field));
|
|
_M_put_node(__p);
|
|
}
|
|
# 426 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
_Link_type
|
|
_M_clone_node(_Const_Link_type __x)
|
|
{
|
|
_Link_type __tmp = _M_create_node(__x->_M_value_field);
|
|
__tmp->_M_color = __x->_M_color;
|
|
__tmp->_M_left = 0;
|
|
__tmp->_M_right = 0;
|
|
return __tmp;
|
|
}
|
|
|
|
protected:
|
|
template<typename _Key_compare,
|
|
bool _Is_pod_comparator = __is_pod(_Key_compare)>
|
|
struct _Rb_tree_impl : public _Node_allocator
|
|
{
|
|
_Key_compare _M_key_compare;
|
|
_Rb_tree_node_base _M_header;
|
|
size_type _M_node_count;
|
|
|
|
_Rb_tree_impl()
|
|
: _Node_allocator(), _M_key_compare(), _M_header(),
|
|
_M_node_count(0)
|
|
{ _M_initialize(); }
|
|
|
|
_Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
|
|
: _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
|
|
_M_node_count(0)
|
|
{ _M_initialize(); }
|
|
# 462 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
private:
|
|
void
|
|
_M_initialize()
|
|
{
|
|
this->_M_header._M_color = _S_red;
|
|
this->_M_header._M_parent = 0;
|
|
this->_M_header._M_left = &this->_M_header;
|
|
this->_M_header._M_right = &this->_M_header;
|
|
}
|
|
};
|
|
|
|
_Rb_tree_impl<_Compare> _M_impl;
|
|
|
|
protected:
|
|
_Base_ptr&
|
|
_M_root()
|
|
{ return this->_M_impl._M_header._M_parent; }
|
|
|
|
_Const_Base_ptr
|
|
_M_root() const
|
|
{ return this->_M_impl._M_header._M_parent; }
|
|
|
|
_Base_ptr&
|
|
_M_leftmost()
|
|
{ return this->_M_impl._M_header._M_left; }
|
|
|
|
_Const_Base_ptr
|
|
_M_leftmost() const
|
|
{ return this->_M_impl._M_header._M_left; }
|
|
|
|
_Base_ptr&
|
|
_M_rightmost()
|
|
{ return this->_M_impl._M_header._M_right; }
|
|
|
|
_Const_Base_ptr
|
|
_M_rightmost() const
|
|
{ return this->_M_impl._M_header._M_right; }
|
|
|
|
_Link_type
|
|
_M_begin()
|
|
{ return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
|
|
|
|
_Const_Link_type
|
|
_M_begin() const
|
|
{
|
|
return static_cast<_Const_Link_type>
|
|
(this->_M_impl._M_header._M_parent);
|
|
}
|
|
|
|
_Link_type
|
|
_M_end()
|
|
{ return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); }
|
|
|
|
_Const_Link_type
|
|
_M_end() const
|
|
{ return reinterpret_cast<_Const_Link_type>(&this->_M_impl._M_header); }
|
|
|
|
static const_reference
|
|
_S_value(_Const_Link_type __x)
|
|
{ return __x->_M_value_field; }
|
|
|
|
static const _Key&
|
|
_S_key(_Const_Link_type __x)
|
|
{ return _KeyOfValue()(_S_value(__x)); }
|
|
|
|
static _Link_type
|
|
_S_left(_Base_ptr __x)
|
|
{ return static_cast<_Link_type>(__x->_M_left); }
|
|
|
|
static _Const_Link_type
|
|
_S_left(_Const_Base_ptr __x)
|
|
{ return static_cast<_Const_Link_type>(__x->_M_left); }
|
|
|
|
static _Link_type
|
|
_S_right(_Base_ptr __x)
|
|
{ return static_cast<_Link_type>(__x->_M_right); }
|
|
|
|
static _Const_Link_type
|
|
_S_right(_Const_Base_ptr __x)
|
|
{ return static_cast<_Const_Link_type>(__x->_M_right); }
|
|
|
|
static const_reference
|
|
_S_value(_Const_Base_ptr __x)
|
|
{ return static_cast<_Const_Link_type>(__x)->_M_value_field; }
|
|
|
|
static const _Key&
|
|
_S_key(_Const_Base_ptr __x)
|
|
{ return _KeyOfValue()(_S_value(__x)); }
|
|
|
|
static _Base_ptr
|
|
_S_minimum(_Base_ptr __x)
|
|
{ return _Rb_tree_node_base::_S_minimum(__x); }
|
|
|
|
static _Const_Base_ptr
|
|
_S_minimum(_Const_Base_ptr __x)
|
|
{ return _Rb_tree_node_base::_S_minimum(__x); }
|
|
|
|
static _Base_ptr
|
|
_S_maximum(_Base_ptr __x)
|
|
{ return _Rb_tree_node_base::_S_maximum(__x); }
|
|
|
|
static _Const_Base_ptr
|
|
_S_maximum(_Const_Base_ptr __x)
|
|
{ return _Rb_tree_node_base::_S_maximum(__x); }
|
|
|
|
public:
|
|
typedef _Rb_tree_iterator<value_type> iterator;
|
|
typedef _Rb_tree_const_iterator<value_type> const_iterator;
|
|
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
|
|
private:
|
|
pair<_Base_ptr, _Base_ptr>
|
|
_M_get_insert_unique_pos(const key_type& __k);
|
|
|
|
pair<_Base_ptr, _Base_ptr>
|
|
_M_get_insert_equal_pos(const key_type& __k);
|
|
|
|
pair<_Base_ptr, _Base_ptr>
|
|
_M_get_insert_hint_unique_pos(const_iterator __pos,
|
|
const key_type& __k);
|
|
|
|
pair<_Base_ptr, _Base_ptr>
|
|
_M_get_insert_hint_equal_pos(const_iterator __pos,
|
|
const key_type& __k);
|
|
# 611 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
iterator
|
|
_M_insert_(_Base_ptr __x, _Base_ptr __y,
|
|
const value_type& __v);
|
|
|
|
|
|
|
|
iterator
|
|
_M_insert_lower(_Base_ptr __y, const value_type& __v);
|
|
|
|
iterator
|
|
_M_insert_equal_lower(const value_type& __x);
|
|
|
|
|
|
_Link_type
|
|
_M_copy(_Const_Link_type __x, _Link_type __p);
|
|
|
|
void
|
|
_M_erase(_Link_type __x);
|
|
|
|
iterator
|
|
_M_lower_bound(_Link_type __x, _Link_type __y,
|
|
const _Key& __k);
|
|
|
|
const_iterator
|
|
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
|
|
const _Key& __k) const;
|
|
|
|
iterator
|
|
_M_upper_bound(_Link_type __x, _Link_type __y,
|
|
const _Key& __k);
|
|
|
|
const_iterator
|
|
_M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
|
|
const _Key& __k) const;
|
|
|
|
public:
|
|
|
|
_Rb_tree() { }
|
|
|
|
_Rb_tree(const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_impl(__comp, _Node_allocator(__a)) { }
|
|
|
|
_Rb_tree(const _Rb_tree& __x)
|
|
: _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
|
|
{
|
|
if (__x._M_root() != 0)
|
|
{
|
|
_M_root() = _M_copy(__x._M_begin(), _M_end());
|
|
_M_leftmost() = _S_minimum(_M_root());
|
|
_M_rightmost() = _S_maximum(_M_root());
|
|
_M_impl._M_node_count = __x._M_impl._M_node_count;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
~_Rb_tree()
|
|
{ _M_erase(_M_begin()); }
|
|
|
|
_Rb_tree&
|
|
operator=(const _Rb_tree& __x);
|
|
|
|
|
|
_Compare
|
|
key_comp() const
|
|
{ return _M_impl._M_key_compare; }
|
|
|
|
iterator
|
|
begin()
|
|
{
|
|
return iterator(static_cast<_Link_type>
|
|
(this->_M_impl._M_header._M_left));
|
|
}
|
|
|
|
const_iterator
|
|
begin() const
|
|
{
|
|
return const_iterator(static_cast<_Const_Link_type>
|
|
(this->_M_impl._M_header._M_left));
|
|
}
|
|
|
|
iterator
|
|
end()
|
|
{ return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
|
|
|
|
const_iterator
|
|
end() const
|
|
{
|
|
return const_iterator(static_cast<_Const_Link_type>
|
|
(&this->_M_impl._M_header));
|
|
}
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return reverse_iterator(end()); }
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return const_reverse_iterator(end()); }
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return reverse_iterator(begin()); }
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return const_reverse_iterator(begin()); }
|
|
|
|
bool
|
|
empty() const
|
|
{ return _M_impl._M_node_count == 0; }
|
|
|
|
size_type
|
|
size() const
|
|
{ return _M_impl._M_node_count; }
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_get_Node_allocator().max_size(); }
|
|
|
|
void
|
|
swap(_Rb_tree& __t);
|
|
# 771 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
pair<iterator, bool>
|
|
_M_insert_unique(const value_type& __x);
|
|
|
|
iterator
|
|
_M_insert_equal(const value_type& __x);
|
|
|
|
iterator
|
|
_M_insert_unique_(const_iterator __position, const value_type& __x);
|
|
|
|
iterator
|
|
_M_insert_equal_(const_iterator __position, const value_type& __x);
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_insert_unique(_InputIterator __first, _InputIterator __last);
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_insert_equal(_InputIterator __first, _InputIterator __last);
|
|
|
|
private:
|
|
void
|
|
_M_erase_aux(const_iterator __position);
|
|
|
|
void
|
|
_M_erase_aux(const_iterator __first, const_iterator __last);
|
|
|
|
public:
|
|
# 824 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
void
|
|
erase(iterator __position)
|
|
{ _M_erase_aux(__position); }
|
|
|
|
void
|
|
erase(const_iterator __position)
|
|
{ _M_erase_aux(__position); }
|
|
|
|
size_type
|
|
erase(const key_type& __x);
|
|
# 846 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
void
|
|
erase(iterator __first, iterator __last)
|
|
{ _M_erase_aux(__first, __last); }
|
|
|
|
void
|
|
erase(const_iterator __first, const_iterator __last)
|
|
{ _M_erase_aux(__first, __last); }
|
|
|
|
void
|
|
erase(const key_type* __first, const key_type* __last);
|
|
|
|
void
|
|
clear()
|
|
{
|
|
_M_erase(_M_begin());
|
|
_M_leftmost() = _M_end();
|
|
_M_root() = 0;
|
|
_M_rightmost() = _M_end();
|
|
_M_impl._M_node_count = 0;
|
|
}
|
|
|
|
|
|
iterator
|
|
find(const key_type& __k);
|
|
|
|
const_iterator
|
|
find(const key_type& __k) const;
|
|
|
|
size_type
|
|
count(const key_type& __k) const;
|
|
|
|
iterator
|
|
lower_bound(const key_type& __k)
|
|
{ return _M_lower_bound(_M_begin(), _M_end(), __k); }
|
|
|
|
const_iterator
|
|
lower_bound(const key_type& __k) const
|
|
{ return _M_lower_bound(_M_begin(), _M_end(), __k); }
|
|
|
|
iterator
|
|
upper_bound(const key_type& __k)
|
|
{ return _M_upper_bound(_M_begin(), _M_end(), __k); }
|
|
|
|
const_iterator
|
|
upper_bound(const key_type& __k) const
|
|
{ return _M_upper_bound(_M_begin(), _M_end(), __k); }
|
|
|
|
pair<iterator, iterator>
|
|
equal_range(const key_type& __k);
|
|
|
|
pair<const_iterator, const_iterator>
|
|
equal_range(const key_type& __k) const;
|
|
|
|
|
|
bool
|
|
__rb_verify() const;
|
|
};
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{
|
|
return __x.size() == __y.size()
|
|
&& std::equal(__x.begin(), __x.end(), __y.begin());
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{
|
|
return std::lexicographical_compare(__x.begin(), __x.end(),
|
|
__y.begin(), __y.end());
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
inline void
|
|
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
# 984 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
|
|
{
|
|
if (this != &__x)
|
|
{
|
|
|
|
clear();
|
|
_M_impl._M_key_compare = __x._M_impl._M_key_compare;
|
|
if (__x._M_root() != 0)
|
|
{
|
|
_M_root() = _M_copy(__x._M_begin(), _M_end());
|
|
_M_leftmost() = _S_minimum(_M_root());
|
|
_M_rightmost() = _S_maximum(_M_root());
|
|
_M_impl._M_node_count = __x._M_impl._M_node_count;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
|
|
|
|
{
|
|
bool __insert_left = (__x != 0 || __p == _M_end()
|
|
|| _M_impl._M_key_compare(_KeyOfValue()(__v),
|
|
_S_key(__p)));
|
|
|
|
_Link_type __z = _M_create_node((__v));
|
|
|
|
_Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
|
|
this->_M_impl._M_header);
|
|
++_M_impl._M_node_count;
|
|
return iterator(__z);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_lower(_Base_ptr __p, const _Val& __v)
|
|
|
|
{
|
|
bool __insert_left = (__p == _M_end()
|
|
|| !_M_impl._M_key_compare(_S_key(__p),
|
|
_KeyOfValue()(__v)));
|
|
|
|
_Link_type __z = _M_create_node((__v));
|
|
|
|
_Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
|
|
this->_M_impl._M_header);
|
|
++_M_impl._M_node_count;
|
|
return iterator(__z);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_equal_lower(const _Val& __v)
|
|
|
|
{
|
|
_Link_type __x = _M_begin();
|
|
_Link_type __y = _M_end();
|
|
while (__x != 0)
|
|
{
|
|
__y = __x;
|
|
__x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
|
|
_S_left(__x) : _S_right(__x);
|
|
}
|
|
return _M_insert_lower(__y, (__v));
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KoV,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
|
|
_Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
|
|
_M_copy(_Const_Link_type __x, _Link_type __p)
|
|
{
|
|
|
|
_Link_type __top = _M_clone_node(__x);
|
|
__top->_M_parent = __p;
|
|
|
|
try
|
|
{
|
|
if (__x->_M_right)
|
|
__top->_M_right = _M_copy(_S_right(__x), __top);
|
|
__p = __top;
|
|
__x = _S_left(__x);
|
|
|
|
while (__x != 0)
|
|
{
|
|
_Link_type __y = _M_clone_node(__x);
|
|
__p->_M_left = __y;
|
|
__y->_M_parent = __p;
|
|
if (__x->_M_right)
|
|
__y->_M_right = _M_copy(_S_right(__x), __y);
|
|
__p = __y;
|
|
__x = _S_left(__x);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_erase(__top);
|
|
throw;
|
|
}
|
|
return __top;
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_erase(_Link_type __x)
|
|
{
|
|
|
|
while (__x != 0)
|
|
{
|
|
_M_erase(_S_right(__x));
|
|
_Link_type __y = _S_left(__x);
|
|
_M_destroy_node(__x);
|
|
__x = __y;
|
|
}
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_lower_bound(_Link_type __x, _Link_type __y,
|
|
const _Key& __k)
|
|
{
|
|
while (__x != 0)
|
|
if (!_M_impl._M_key_compare(_S_key(__x), __k))
|
|
__y = __x, __x = _S_left(__x);
|
|
else
|
|
__x = _S_right(__x);
|
|
return iterator(__y);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::const_iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
|
|
const _Key& __k) const
|
|
{
|
|
while (__x != 0)
|
|
if (!_M_impl._M_key_compare(_S_key(__x), __k))
|
|
__y = __x, __x = _S_left(__x);
|
|
else
|
|
__x = _S_right(__x);
|
|
return const_iterator(__y);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_upper_bound(_Link_type __x, _Link_type __y,
|
|
const _Key& __k)
|
|
{
|
|
while (__x != 0)
|
|
if (_M_impl._M_key_compare(__k, _S_key(__x)))
|
|
__y = __x, __x = _S_left(__x);
|
|
else
|
|
__x = _S_right(__x);
|
|
return iterator(__y);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::const_iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
|
|
const _Key& __k) const
|
|
{
|
|
while (__x != 0)
|
|
if (_M_impl._M_key_compare(__k, _S_key(__x)))
|
|
__y = __x, __x = _S_left(__x);
|
|
else
|
|
__x = _S_right(__x);
|
|
return const_iterator(__y);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::iterator,
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::iterator>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
equal_range(const _Key& __k)
|
|
{
|
|
_Link_type __x = _M_begin();
|
|
_Link_type __y = _M_end();
|
|
while (__x != 0)
|
|
{
|
|
if (_M_impl._M_key_compare(_S_key(__x), __k))
|
|
__x = _S_right(__x);
|
|
else if (_M_impl._M_key_compare(__k, _S_key(__x)))
|
|
__y = __x, __x = _S_left(__x);
|
|
else
|
|
{
|
|
_Link_type __xu(__x), __yu(__y);
|
|
__y = __x, __x = _S_left(__x);
|
|
__xu = _S_right(__xu);
|
|
return pair<iterator,
|
|
iterator>(_M_lower_bound(__x, __y, __k),
|
|
_M_upper_bound(__xu, __yu, __k));
|
|
}
|
|
}
|
|
return pair<iterator, iterator>(iterator(__y),
|
|
iterator(__y));
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::const_iterator,
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::const_iterator>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
equal_range(const _Key& __k) const
|
|
{
|
|
_Const_Link_type __x = _M_begin();
|
|
_Const_Link_type __y = _M_end();
|
|
while (__x != 0)
|
|
{
|
|
if (_M_impl._M_key_compare(_S_key(__x), __k))
|
|
__x = _S_right(__x);
|
|
else if (_M_impl._M_key_compare(__k, _S_key(__x)))
|
|
__y = __x, __x = _S_left(__x);
|
|
else
|
|
{
|
|
_Const_Link_type __xu(__x), __yu(__y);
|
|
__y = __x, __x = _S_left(__x);
|
|
__xu = _S_right(__xu);
|
|
return pair<const_iterator,
|
|
const_iterator>(_M_lower_bound(__x, __y, __k),
|
|
_M_upper_bound(__xu, __yu, __k));
|
|
}
|
|
}
|
|
return pair<const_iterator, const_iterator>(const_iterator(__y),
|
|
const_iterator(__y));
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
|
|
{
|
|
if (_M_root() == 0)
|
|
{
|
|
if (__t._M_root() != 0)
|
|
{
|
|
_M_root() = __t._M_root();
|
|
_M_leftmost() = __t._M_leftmost();
|
|
_M_rightmost() = __t._M_rightmost();
|
|
_M_root()->_M_parent = _M_end();
|
|
|
|
__t._M_root() = 0;
|
|
__t._M_leftmost() = __t._M_end();
|
|
__t._M_rightmost() = __t._M_end();
|
|
}
|
|
}
|
|
else if (__t._M_root() == 0)
|
|
{
|
|
__t._M_root() = _M_root();
|
|
__t._M_leftmost() = _M_leftmost();
|
|
__t._M_rightmost() = _M_rightmost();
|
|
__t._M_root()->_M_parent = __t._M_end();
|
|
|
|
_M_root() = 0;
|
|
_M_leftmost() = _M_end();
|
|
_M_rightmost() = _M_end();
|
|
}
|
|
else
|
|
{
|
|
std::swap(_M_root(),__t._M_root());
|
|
std::swap(_M_leftmost(),__t._M_leftmost());
|
|
std::swap(_M_rightmost(),__t._M_rightmost());
|
|
|
|
_M_root()->_M_parent = _M_end();
|
|
__t._M_root()->_M_parent = __t._M_end();
|
|
}
|
|
|
|
std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
|
|
std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
|
|
|
|
|
|
|
|
std::__alloc_swap<_Node_allocator>::
|
|
_S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr,
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_get_insert_unique_pos(const key_type& __k)
|
|
{
|
|
typedef pair<_Base_ptr, _Base_ptr> _Res;
|
|
_Link_type __x = _M_begin();
|
|
_Link_type __y = _M_end();
|
|
bool __comp = true;
|
|
while (__x != 0)
|
|
{
|
|
__y = __x;
|
|
__comp = _M_impl._M_key_compare(__k, _S_key(__x));
|
|
__x = __comp ? _S_left(__x) : _S_right(__x);
|
|
}
|
|
iterator __j = iterator(__y);
|
|
if (__comp)
|
|
{
|
|
if (__j == begin())
|
|
return _Res(__x, __y);
|
|
else
|
|
--__j;
|
|
}
|
|
if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
|
|
return _Res(__x, __y);
|
|
return _Res(__j._M_node, 0);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr,
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_get_insert_equal_pos(const key_type& __k)
|
|
{
|
|
typedef pair<_Base_ptr, _Base_ptr> _Res;
|
|
_Link_type __x = _M_begin();
|
|
_Link_type __y = _M_end();
|
|
while (__x != 0)
|
|
{
|
|
__y = __x;
|
|
__x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
|
|
_S_left(__x) : _S_right(__x);
|
|
}
|
|
return _Res(__x, __y);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::iterator, bool>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_unique(const _Val& __v)
|
|
|
|
{
|
|
typedef pair<iterator, bool> _Res;
|
|
pair<_Base_ptr, _Base_ptr> __res
|
|
= _M_get_insert_unique_pos(_KeyOfValue()(__v));
|
|
|
|
if (__res.second)
|
|
return _Res(_M_insert_(__res.first, __res.second,
|
|
(__v)),
|
|
true);
|
|
|
|
return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_equal(const _Val& __v)
|
|
|
|
{
|
|
pair<_Base_ptr, _Base_ptr> __res
|
|
= _M_get_insert_equal_pos(_KeyOfValue()(__v));
|
|
return _M_insert_(__res.first, __res.second, (__v));
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr,
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_get_insert_hint_unique_pos(const_iterator __position,
|
|
const key_type& __k)
|
|
{
|
|
iterator __pos = __position._M_const_cast();
|
|
typedef pair<_Base_ptr, _Base_ptr> _Res;
|
|
|
|
|
|
if (__pos._M_node == _M_end())
|
|
{
|
|
if (size() > 0
|
|
&& _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
|
|
return _Res(0, _M_rightmost());
|
|
else
|
|
return _M_get_insert_unique_pos(__k);
|
|
}
|
|
else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
|
|
{
|
|
|
|
iterator __before = __pos;
|
|
if (__pos._M_node == _M_leftmost())
|
|
return _Res(_M_leftmost(), _M_leftmost());
|
|
else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
|
|
{
|
|
if (_S_right(__before._M_node) == 0)
|
|
return _Res(0, __before._M_node);
|
|
else
|
|
return _Res(__pos._M_node, __pos._M_node);
|
|
}
|
|
else
|
|
return _M_get_insert_unique_pos(__k);
|
|
}
|
|
else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
|
|
{
|
|
|
|
iterator __after = __pos;
|
|
if (__pos._M_node == _M_rightmost())
|
|
return _Res(0, _M_rightmost());
|
|
else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
|
|
{
|
|
if (_S_right(__pos._M_node) == 0)
|
|
return _Res(0, __pos._M_node);
|
|
else
|
|
return _Res(__after._M_node, __after._M_node);
|
|
}
|
|
else
|
|
return _M_get_insert_unique_pos(__k);
|
|
}
|
|
else
|
|
|
|
return _Res(__pos._M_node, 0);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_unique_(const_iterator __position, const _Val& __v)
|
|
|
|
{
|
|
pair<_Base_ptr, _Base_ptr> __res
|
|
= _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
|
|
|
|
if (__res.second)
|
|
return _M_insert_(__res.first, __res.second,
|
|
(__v));
|
|
return iterator(static_cast<_Link_type>(__res.first));
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr,
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::_Base_ptr>
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
|
|
{
|
|
iterator __pos = __position._M_const_cast();
|
|
typedef pair<_Base_ptr, _Base_ptr> _Res;
|
|
|
|
|
|
if (__pos._M_node == _M_end())
|
|
{
|
|
if (size() > 0
|
|
&& !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
|
|
return _Res(0, _M_rightmost());
|
|
else
|
|
return _M_get_insert_equal_pos(__k);
|
|
}
|
|
else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
|
|
{
|
|
|
|
iterator __before = __pos;
|
|
if (__pos._M_node == _M_leftmost())
|
|
return _Res(_M_leftmost(), _M_leftmost());
|
|
else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
|
|
{
|
|
if (_S_right(__before._M_node) == 0)
|
|
return _Res(0, __before._M_node);
|
|
else
|
|
return _Res(__pos._M_node, __pos._M_node);
|
|
}
|
|
else
|
|
return _M_get_insert_equal_pos(__k);
|
|
}
|
|
else
|
|
{
|
|
|
|
iterator __after = __pos;
|
|
if (__pos._M_node == _M_rightmost())
|
|
return _Res(0, _M_rightmost());
|
|
else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
|
|
{
|
|
if (_S_right(__pos._M_node) == 0)
|
|
return _Res(0, __pos._M_node);
|
|
else
|
|
return _Res(__after._M_node, __after._M_node);
|
|
}
|
|
else
|
|
return _Res(0, 0);
|
|
}
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
|
|
|
|
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
|
|
|
|
|
|
_M_insert_equal_(const_iterator __position, const _Val& __v)
|
|
|
|
{
|
|
pair<_Base_ptr, _Base_ptr> __res
|
|
= _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
|
|
|
|
if (__res.second)
|
|
return _M_insert_(__res.first, __res.second,
|
|
(__v));
|
|
|
|
return _M_insert_equal_lower((__v));
|
|
}
|
|
# 1714 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
|
|
template<typename _Key, typename _Val, typename _KoV,
|
|
typename _Cmp, typename _Alloc>
|
|
template<class _II>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
|
|
_M_insert_unique(_II __first, _II __last)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
_M_insert_unique_(end(), *__first);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KoV,
|
|
typename _Cmp, typename _Alloc>
|
|
template<class _II>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
|
|
_M_insert_equal(_II __first, _II __last)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
_M_insert_equal_(end(), *__first);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_erase_aux(const_iterator __position)
|
|
{
|
|
_Link_type __y =
|
|
static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
|
|
(const_cast<_Base_ptr>(__position._M_node),
|
|
this->_M_impl._M_header));
|
|
_M_destroy_node(__y);
|
|
--_M_impl._M_node_count;
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
_M_erase_aux(const_iterator __first, const_iterator __last)
|
|
{
|
|
if (__first == begin() && __last == end())
|
|
clear();
|
|
else
|
|
while (__first != __last)
|
|
erase(__first++);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
erase(const _Key& __x)
|
|
{
|
|
pair<iterator, iterator> __p = equal_range(__x);
|
|
const size_type __old_size = size();
|
|
erase(__p.first, __p.second);
|
|
return __old_size - size();
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
void
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
erase(const _Key* __first, const _Key* __last)
|
|
{
|
|
while (__first != __last)
|
|
erase(*__first++);
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
find(const _Key& __k)
|
|
{
|
|
iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
|
|
return (__j == end()
|
|
|| _M_impl._M_key_compare(__k,
|
|
_S_key(__j._M_node))) ? end() : __j;
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue,
|
|
_Compare, _Alloc>::const_iterator
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
find(const _Key& __k) const
|
|
{
|
|
const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
|
|
return (__j == end()
|
|
|| _M_impl._M_key_compare(__k,
|
|
_S_key(__j._M_node))) ? end() : __j;
|
|
}
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
|
|
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
|
|
count(const _Key& __k) const
|
|
{
|
|
pair<const_iterator, const_iterator> __p = equal_range(__k);
|
|
const size_type __n = std::distance(__p.first, __p.second);
|
|
return __n;
|
|
}
|
|
|
|
__attribute__ ((__pure__)) unsigned int
|
|
_Rb_tree_black_count(const _Rb_tree_node_base* __node,
|
|
const _Rb_tree_node_base* __root) throw ();
|
|
|
|
template<typename _Key, typename _Val, typename _KeyOfValue,
|
|
typename _Compare, typename _Alloc>
|
|
bool
|
|
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
|
|
{
|
|
if (_M_impl._M_node_count == 0 || begin() == end())
|
|
return _M_impl._M_node_count == 0 && begin() == end()
|
|
&& this->_M_impl._M_header._M_left == _M_end()
|
|
&& this->_M_impl._M_header._M_right == _M_end();
|
|
|
|
unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
|
|
for (const_iterator __it = begin(); __it != end(); ++__it)
|
|
{
|
|
_Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
|
|
_Const_Link_type __L = _S_left(__x);
|
|
_Const_Link_type __R = _S_right(__x);
|
|
|
|
if (__x->_M_color == _S_red)
|
|
if ((__L && __L->_M_color == _S_red)
|
|
|| (__R && __R->_M_color == _S_red))
|
|
return false;
|
|
|
|
if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
|
|
return false;
|
|
if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
|
|
return false;
|
|
|
|
if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
|
|
return false;
|
|
}
|
|
|
|
if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
|
|
return false;
|
|
if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
}
|
|
# 61 "/usr/include/c++/4.8.2/map" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_map.h" 1 3
|
|
# 66 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 94 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
|
|
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
|
|
class map
|
|
{
|
|
public:
|
|
typedef _Key key_type;
|
|
typedef _Tp mapped_type;
|
|
typedef std::pair<const _Key, _Tp> value_type;
|
|
typedef _Compare key_compare;
|
|
typedef _Alloc allocator_type;
|
|
|
|
private:
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
class value_compare
|
|
: public std::binary_function<value_type, value_type, bool>
|
|
{
|
|
friend class map<_Key, _Tp, _Compare, _Alloc>;
|
|
protected:
|
|
_Compare comp;
|
|
|
|
value_compare(_Compare __c)
|
|
: comp(__c) { }
|
|
|
|
public:
|
|
bool operator()(const value_type& __x, const value_type& __y) const
|
|
{ return comp(__x.first, __y.first); }
|
|
};
|
|
|
|
private:
|
|
|
|
typedef typename _Alloc::template rebind<value_type>::other
|
|
_Pair_alloc_type;
|
|
|
|
typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
|
|
key_compare, _Pair_alloc_type> _Rep_type;
|
|
|
|
|
|
_Rep_type _M_t;
|
|
|
|
public:
|
|
|
|
|
|
typedef typename _Pair_alloc_type::pointer pointer;
|
|
typedef typename _Pair_alloc_type::const_pointer const_pointer;
|
|
typedef typename _Pair_alloc_type::reference reference;
|
|
typedef typename _Pair_alloc_type::const_reference const_reference;
|
|
typedef typename _Rep_type::iterator iterator;
|
|
typedef typename _Rep_type::const_iterator const_iterator;
|
|
typedef typename _Rep_type::size_type size_type;
|
|
typedef typename _Rep_type::difference_type difference_type;
|
|
typedef typename _Rep_type::reverse_iterator reverse_iterator;
|
|
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
map()
|
|
: _M_t() { }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
map(const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Pair_alloc_type(__a)) { }
|
|
# 180 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
map(const map& __x)
|
|
: _M_t(__x._M_t) { }
|
|
# 223 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
template<typename _InputIterator>
|
|
map(_InputIterator __first, _InputIterator __last)
|
|
: _M_t()
|
|
{ _M_t._M_insert_unique(__first, __last); }
|
|
# 240 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
template<typename _InputIterator>
|
|
map(_InputIterator __first, _InputIterator __last,
|
|
const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Pair_alloc_type(__a))
|
|
{ _M_t._M_insert_unique(__first, __last); }
|
|
# 263 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
map&
|
|
operator=(const map& __x)
|
|
{
|
|
_M_t = __x._M_t;
|
|
return *this;
|
|
}
|
|
# 309 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_t.get_allocator()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin()
|
|
{ return _M_t.begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return _M_t.begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end()
|
|
{ return _M_t.end(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return _M_t.end(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return _M_t.rbegin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return _M_t.rbegin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return _M_t.rend(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return _M_t.rend(); }
|
|
# 428 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
bool
|
|
empty() const
|
|
{ return _M_t.empty(); }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return _M_t.size(); }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_t.max_size(); }
|
|
# 455 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
mapped_type&
|
|
operator[](const key_type& __k)
|
|
{
|
|
|
|
|
|
|
|
iterator __i = lower_bound(__k);
|
|
|
|
if (__i == end() || key_comp()(__k, (*__i).first))
|
|
|
|
|
|
|
|
|
|
|
|
__i = insert(__i, value_type(__k, mapped_type()));
|
|
|
|
return (*__i).second;
|
|
}
|
|
# 500 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
mapped_type&
|
|
at(const key_type& __k)
|
|
{
|
|
iterator __i = lower_bound(__k);
|
|
if (__i == end() || key_comp()(__k, (*__i).first))
|
|
__throw_out_of_range(("map::at"));
|
|
return (*__i).second;
|
|
}
|
|
|
|
const mapped_type&
|
|
at(const key_type& __k) const
|
|
{
|
|
const_iterator __i = lower_bound(__k);
|
|
if (__i == end() || key_comp()(__k, (*__i).first))
|
|
__throw_out_of_range(("map::at"));
|
|
return (*__i).second;
|
|
}
|
|
# 593 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
std::pair<iterator, bool>
|
|
insert(const value_type& __x)
|
|
{ return _M_t._M_insert_unique(__x); }
|
|
# 642 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
iterator
|
|
|
|
|
|
|
|
insert(iterator __position, const value_type& __x)
|
|
|
|
{ return _M_t._M_insert_unique_(__position, __x); }
|
|
# 668 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(_InputIterator __first, _InputIterator __last)
|
|
{ _M_t._M_insert_unique(__first, __last); }
|
|
# 709 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
void
|
|
erase(iterator __position)
|
|
{ _M_t.erase(__position); }
|
|
# 725 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
size_type
|
|
erase(const key_type& __x)
|
|
{ return _M_t.erase(__x); }
|
|
# 761 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
void
|
|
erase(iterator __first, iterator __last)
|
|
{ _M_t.erase(__first, __last); }
|
|
# 777 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
void
|
|
swap(map& __x)
|
|
{ _M_t.swap(__x._M_t); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
clear()
|
|
{ _M_t.clear(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
key_compare
|
|
key_comp() const
|
|
{ return _M_t.key_comp(); }
|
|
|
|
|
|
|
|
|
|
|
|
value_compare
|
|
value_comp() const
|
|
{ return value_compare(_M_t.key_comp()); }
|
|
# 820 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
iterator
|
|
find(const key_type& __x)
|
|
{ return _M_t.find(__x); }
|
|
# 835 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
const_iterator
|
|
find(const key_type& __x) const
|
|
{ return _M_t.find(__x); }
|
|
# 847 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
size_type
|
|
count(const key_type& __x) const
|
|
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
|
|
# 862 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
iterator
|
|
lower_bound(const key_type& __x)
|
|
{ return _M_t.lower_bound(__x); }
|
|
# 877 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
const_iterator
|
|
lower_bound(const key_type& __x) const
|
|
{ return _M_t.lower_bound(__x); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
upper_bound(const key_type& __x)
|
|
{ return _M_t.upper_bound(__x); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
upper_bound(const key_type& __x) const
|
|
{ return _M_t.upper_bound(__x); }
|
|
# 916 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
std::pair<iterator, iterator>
|
|
equal_range(const key_type& __x)
|
|
{ return _M_t.equal_range(__x); }
|
|
# 935 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
std::pair<const_iterator, const_iterator>
|
|
equal_range(const key_type& __x) const
|
|
{ return _M_t.equal_range(__x); }
|
|
|
|
template<typename _K1, typename _T1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator==(const map<_K1, _T1, _C1, _A1>&,
|
|
const map<_K1, _T1, _C1, _A1>&);
|
|
|
|
template<typename _K1, typename _T1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator<(const map<_K1, _T1, _C1, _A1>&,
|
|
const map<_K1, _T1, _C1, _A1>&);
|
|
};
|
|
# 960 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t == __y._M_t; }
|
|
# 977 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t < __y._M_t; }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline void
|
|
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
map<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
}
|
|
# 62 "/usr/include/c++/4.8.2/map" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 1 3
|
|
# 64 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 92 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
template <typename _Key, typename _Tp,
|
|
typename _Compare = std::less<_Key>,
|
|
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
|
|
class multimap
|
|
{
|
|
public:
|
|
typedef _Key key_type;
|
|
typedef _Tp mapped_type;
|
|
typedef std::pair<const _Key, _Tp> value_type;
|
|
typedef _Compare key_compare;
|
|
typedef _Alloc allocator_type;
|
|
|
|
private:
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
class value_compare
|
|
: public std::binary_function<value_type, value_type, bool>
|
|
{
|
|
friend class multimap<_Key, _Tp, _Compare, _Alloc>;
|
|
protected:
|
|
_Compare comp;
|
|
|
|
value_compare(_Compare __c)
|
|
: comp(__c) { }
|
|
|
|
public:
|
|
bool operator()(const value_type& __x, const value_type& __y) const
|
|
{ return comp(__x.first, __y.first); }
|
|
};
|
|
|
|
private:
|
|
|
|
typedef typename _Alloc::template rebind<value_type>::other
|
|
_Pair_alloc_type;
|
|
|
|
typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
|
|
key_compare, _Pair_alloc_type> _Rep_type;
|
|
|
|
_Rep_type _M_t;
|
|
|
|
public:
|
|
|
|
|
|
typedef typename _Pair_alloc_type::pointer pointer;
|
|
typedef typename _Pair_alloc_type::const_pointer const_pointer;
|
|
typedef typename _Pair_alloc_type::reference reference;
|
|
typedef typename _Pair_alloc_type::const_reference const_reference;
|
|
typedef typename _Rep_type::iterator iterator;
|
|
typedef typename _Rep_type::const_iterator const_iterator;
|
|
typedef typename _Rep_type::size_type size_type;
|
|
typedef typename _Rep_type::difference_type difference_type;
|
|
typedef typename _Rep_type::reverse_iterator reverse_iterator;
|
|
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
multimap()
|
|
: _M_t() { }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
multimap(const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Pair_alloc_type(__a)) { }
|
|
# 177 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
multimap(const multimap& __x)
|
|
: _M_t(__x._M_t) { }
|
|
# 218 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
template<typename _InputIterator>
|
|
multimap(_InputIterator __first, _InputIterator __last)
|
|
: _M_t()
|
|
{ _M_t._M_insert_equal(__first, __last); }
|
|
# 234 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
template<typename _InputIterator>
|
|
multimap(_InputIterator __first, _InputIterator __last,
|
|
const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Pair_alloc_type(__a))
|
|
{ _M_t._M_insert_equal(__first, __last); }
|
|
# 257 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
multimap&
|
|
operator=(const multimap& __x)
|
|
{
|
|
_M_t = __x._M_t;
|
|
return *this;
|
|
}
|
|
# 303 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_t.get_allocator()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin()
|
|
{ return _M_t.begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return _M_t.begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end()
|
|
{ return _M_t.end(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return _M_t.end(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return _M_t.rbegin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return _M_t.rbegin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return _M_t.rend(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return _M_t.rend(); }
|
|
# 420 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
bool
|
|
empty() const
|
|
{ return _M_t.empty(); }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return _M_t.size(); }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_t.max_size(); }
|
|
# 500 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
iterator
|
|
insert(const value_type& __x)
|
|
{ return _M_t._M_insert_equal(__x); }
|
|
# 533 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
iterator
|
|
|
|
|
|
|
|
insert(iterator __position, const value_type& __x)
|
|
|
|
{ return _M_t._M_insert_equal_(__position, __x); }
|
|
# 560 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(_InputIterator __first, _InputIterator __last)
|
|
{ _M_t._M_insert_equal(__first, __last); }
|
|
# 614 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
void
|
|
erase(iterator __position)
|
|
{ _M_t.erase(__position); }
|
|
# 630 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
size_type
|
|
erase(const key_type& __x)
|
|
{ return _M_t.erase(__x); }
|
|
# 670 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
void
|
|
erase(iterator __first, iterator __last)
|
|
{ _M_t.erase(__first, __last); }
|
|
# 686 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
void
|
|
swap(multimap& __x)
|
|
{ _M_t.swap(__x._M_t); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
clear()
|
|
{ _M_t.clear(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
key_compare
|
|
key_comp() const
|
|
{ return _M_t.key_comp(); }
|
|
|
|
|
|
|
|
|
|
|
|
value_compare
|
|
value_comp() const
|
|
{ return value_compare(_M_t.key_comp()); }
|
|
# 729 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
iterator
|
|
find(const key_type& __x)
|
|
{ return _M_t.find(__x); }
|
|
# 744 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
const_iterator
|
|
find(const key_type& __x) const
|
|
{ return _M_t.find(__x); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
size_type
|
|
count(const key_type& __x) const
|
|
{ return _M_t.count(__x); }
|
|
# 768 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
iterator
|
|
lower_bound(const key_type& __x)
|
|
{ return _M_t.lower_bound(__x); }
|
|
# 783 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
const_iterator
|
|
lower_bound(const key_type& __x) const
|
|
{ return _M_t.lower_bound(__x); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
upper_bound(const key_type& __x)
|
|
{ return _M_t.upper_bound(__x); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
upper_bound(const key_type& __x) const
|
|
{ return _M_t.upper_bound(__x); }
|
|
# 820 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
std::pair<iterator, iterator>
|
|
equal_range(const key_type& __x)
|
|
{ return _M_t.equal_range(__x); }
|
|
# 837 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
std::pair<const_iterator, const_iterator>
|
|
equal_range(const key_type& __x) const
|
|
{ return _M_t.equal_range(__x); }
|
|
|
|
template<typename _K1, typename _T1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator==(const multimap<_K1, _T1, _C1, _A1>&,
|
|
const multimap<_K1, _T1, _C1, _A1>&);
|
|
|
|
template<typename _K1, typename _T1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator<(const multimap<_K1, _T1, _C1, _A1>&,
|
|
const multimap<_K1, _T1, _C1, _A1>&);
|
|
};
|
|
# 862 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t == __y._M_t; }
|
|
# 879 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t < __y._M_t; }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
|
|
inline void
|
|
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
|
|
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
}
|
|
# 63 "/usr/include/c++/4.8.2/map" 2 3
|
|
# 11 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/c++/4.8.2/vector" 1 3
|
|
# 58 "/usr/include/c++/4.8.2/vector" 3
|
|
|
|
# 59 "/usr/include/c++/4.8.2/vector" 3
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_construct.h" 1 3
|
|
# 61 "/usr/include/c++/4.8.2/bits/stl_construct.h" 3
|
|
# 1 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 1 3
|
|
# 32 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
|
|
|
|
# 33 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
|
|
# 41 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
|
|
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 120 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
|
|
template<typename _Alloc>
|
|
struct __alloc_traits
|
|
|
|
|
|
|
|
{
|
|
typedef _Alloc allocator_type;
|
|
# 199 "/usr/include/c++/4.8.2/ext/alloc_traits.h" 3
|
|
typedef typename _Alloc::pointer pointer;
|
|
typedef typename _Alloc::const_pointer const_pointer;
|
|
typedef typename _Alloc::value_type value_type;
|
|
typedef typename _Alloc::reference reference;
|
|
typedef typename _Alloc::const_reference const_reference;
|
|
typedef typename _Alloc::size_type size_type;
|
|
typedef typename _Alloc::difference_type difference_type;
|
|
|
|
static pointer
|
|
allocate(_Alloc& __a, size_type __n)
|
|
{ return __a.allocate(__n); }
|
|
|
|
static void deallocate(_Alloc& __a, pointer __p, size_type __n)
|
|
{ __a.deallocate(__p, __n); }
|
|
|
|
template<typename _Tp>
|
|
static void construct(_Alloc& __a, pointer __p, const _Tp& __arg)
|
|
{ __a.construct(__p, __arg); }
|
|
|
|
static void destroy(_Alloc& __a, pointer __p)
|
|
{ __a.destroy(__p); }
|
|
|
|
static size_type max_size(const _Alloc& __a)
|
|
{ return __a.max_size(); }
|
|
|
|
static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; }
|
|
|
|
static void _S_on_swap(_Alloc& __a, _Alloc& __b)
|
|
{
|
|
|
|
|
|
std::__alloc_swap<_Alloc>::_S_do_it(__a, __b);
|
|
}
|
|
|
|
template<typename _Tp>
|
|
struct rebind
|
|
{ typedef typename _Alloc::template rebind<_Tp>::other other; };
|
|
|
|
};
|
|
|
|
|
|
}
|
|
# 62 "/usr/include/c++/4.8.2/bits/stl_construct.h" 2 3
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 77 "/usr/include/c++/4.8.2/bits/stl_construct.h" 3
|
|
template<typename _T1, typename _T2>
|
|
inline void
|
|
_Construct(_T1* __p, const _T2& __value)
|
|
{
|
|
|
|
|
|
::new(static_cast<void*>(__p)) _T1(__value);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
inline void
|
|
_Destroy(_Tp* __pointer)
|
|
{ __pointer->~_Tp(); }
|
|
|
|
template<bool>
|
|
struct _Destroy_aux
|
|
{
|
|
template<typename _ForwardIterator>
|
|
static void
|
|
__destroy(_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
std::_Destroy(std::__addressof(*__first));
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct _Destroy_aux<true>
|
|
{
|
|
template<typename _ForwardIterator>
|
|
static void
|
|
__destroy(_ForwardIterator, _ForwardIterator) { }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
inline void
|
|
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type
|
|
_Value_type;
|
|
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
|
|
__destroy(__first, __last);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _ForwardIterator, typename _Allocator>
|
|
void
|
|
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
|
|
_Allocator& __alloc)
|
|
{
|
|
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
|
|
for (; __first != __last; ++__first)
|
|
__traits::destroy(__alloc, std::__addressof(*__first));
|
|
}
|
|
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
inline void
|
|
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
|
|
allocator<_Tp>&)
|
|
{
|
|
_Destroy(__first, __last);
|
|
}
|
|
|
|
|
|
}
|
|
# 63 "/usr/include/c++/4.8.2/vector" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<bool _TrivialValueTypes>
|
|
struct __uninitialized_copy
|
|
{
|
|
template<typename _InputIterator, typename _ForwardIterator>
|
|
static _ForwardIterator
|
|
__uninit_copy(_InputIterator __first, _InputIterator __last,
|
|
_ForwardIterator __result)
|
|
{
|
|
_ForwardIterator __cur = __result;
|
|
try
|
|
{
|
|
for (; __first != __last; ++__first, ++__cur)
|
|
std::_Construct(std::__addressof(*__cur), *__first);
|
|
return __cur;
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__result, __cur);
|
|
throw;
|
|
}
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct __uninitialized_copy<true>
|
|
{
|
|
template<typename _InputIterator, typename _ForwardIterator>
|
|
static _ForwardIterator
|
|
__uninit_copy(_InputIterator __first, _InputIterator __last,
|
|
_ForwardIterator __result)
|
|
{ return std::copy(__first, __last, __result); }
|
|
};
|
|
# 105 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
|
|
template<typename _InputIterator, typename _ForwardIterator>
|
|
inline _ForwardIterator
|
|
uninitialized_copy(_InputIterator __first, _InputIterator __last,
|
|
_ForwardIterator __result)
|
|
{
|
|
typedef typename iterator_traits<_InputIterator>::value_type
|
|
_ValueType1;
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type
|
|
_ValueType2;
|
|
|
|
return std::__uninitialized_copy<(__is_trivial(_ValueType1)
|
|
&& __is_trivial(_ValueType2))>::
|
|
__uninit_copy(__first, __last, __result);
|
|
}
|
|
|
|
|
|
template<bool _TrivialValueType>
|
|
struct __uninitialized_fill
|
|
{
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
static void
|
|
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __x)
|
|
{
|
|
_ForwardIterator __cur = __first;
|
|
try
|
|
{
|
|
for (; __cur != __last; ++__cur)
|
|
std::_Construct(std::__addressof(*__cur), __x);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__first, __cur);
|
|
throw;
|
|
}
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct __uninitialized_fill<true>
|
|
{
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
static void
|
|
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __x)
|
|
{ std::fill(__first, __last, __x); }
|
|
};
|
|
# 162 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
|
|
template<typename _ForwardIterator, typename _Tp>
|
|
inline void
|
|
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __x)
|
|
{
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type
|
|
_ValueType;
|
|
|
|
std::__uninitialized_fill<__is_trivial(_ValueType)>::
|
|
__uninit_fill(__first, __last, __x);
|
|
}
|
|
|
|
|
|
template<bool _TrivialValueType>
|
|
struct __uninitialized_fill_n
|
|
{
|
|
template<typename _ForwardIterator, typename _Size, typename _Tp>
|
|
static void
|
|
__uninit_fill_n(_ForwardIterator __first, _Size __n,
|
|
const _Tp& __x)
|
|
{
|
|
_ForwardIterator __cur = __first;
|
|
try
|
|
{
|
|
for (; __n > 0; --__n, ++__cur)
|
|
std::_Construct(std::__addressof(*__cur), __x);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__first, __cur);
|
|
throw;
|
|
}
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct __uninitialized_fill_n<true>
|
|
{
|
|
template<typename _ForwardIterator, typename _Size, typename _Tp>
|
|
static void
|
|
__uninit_fill_n(_ForwardIterator __first, _Size __n,
|
|
const _Tp& __x)
|
|
{ std::fill_n(__first, __n, __x); }
|
|
};
|
|
# 216 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
|
|
template<typename _ForwardIterator, typename _Size, typename _Tp>
|
|
inline void
|
|
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
|
|
{
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type
|
|
_ValueType;
|
|
|
|
std::__uninitialized_fill_n<__is_trivial(_ValueType)>::
|
|
__uninit_fill_n(__first, __n, __x);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _InputIterator, typename _ForwardIterator,
|
|
typename _Allocator>
|
|
_ForwardIterator
|
|
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
|
|
_ForwardIterator __result, _Allocator& __alloc)
|
|
{
|
|
_ForwardIterator __cur = __result;
|
|
try
|
|
{
|
|
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
|
|
for (; __first != __last; ++__first, ++__cur)
|
|
__traits::construct(__alloc, std::__addressof(*__cur), *__first);
|
|
return __cur;
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__result, __cur, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
|
|
inline _ForwardIterator
|
|
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
|
|
_ForwardIterator __result, allocator<_Tp>&)
|
|
{ return std::uninitialized_copy(__first, __last, __result); }
|
|
|
|
template<typename _InputIterator, typename _ForwardIterator,
|
|
typename _Allocator>
|
|
inline _ForwardIterator
|
|
__uninitialized_move_a(_InputIterator __first, _InputIterator __last,
|
|
_ForwardIterator __result, _Allocator& __alloc)
|
|
{
|
|
return std::__uninitialized_copy_a((__first),
|
|
(__last),
|
|
__result, __alloc);
|
|
}
|
|
|
|
template<typename _InputIterator, typename _ForwardIterator,
|
|
typename _Allocator>
|
|
inline _ForwardIterator
|
|
__uninitialized_move_if_noexcept_a(_InputIterator __first,
|
|
_InputIterator __last,
|
|
_ForwardIterator __result,
|
|
_Allocator& __alloc)
|
|
{
|
|
return std::__uninitialized_copy_a
|
|
((__first),
|
|
(__last), __result, __alloc);
|
|
}
|
|
|
|
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
|
|
void
|
|
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __x, _Allocator& __alloc)
|
|
{
|
|
_ForwardIterator __cur = __first;
|
|
try
|
|
{
|
|
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
|
|
for (; __cur != __last; ++__cur)
|
|
__traits::construct(__alloc, std::__addressof(*__cur), __x);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__first, __cur, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
|
|
inline void
|
|
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
|
|
const _Tp& __x, allocator<_Tp2>&)
|
|
{ std::uninitialized_fill(__first, __last, __x); }
|
|
|
|
template<typename _ForwardIterator, typename _Size, typename _Tp,
|
|
typename _Allocator>
|
|
void
|
|
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
|
|
const _Tp& __x, _Allocator& __alloc)
|
|
{
|
|
_ForwardIterator __cur = __first;
|
|
try
|
|
{
|
|
typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
|
|
for (; __n > 0; --__n, ++__cur)
|
|
__traits::construct(__alloc, std::__addressof(*__cur), __x);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__first, __cur, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename _ForwardIterator, typename _Size, typename _Tp,
|
|
typename _Tp2>
|
|
inline void
|
|
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
|
|
const _Tp& __x, allocator<_Tp2>&)
|
|
{ std::uninitialized_fill_n(__first, __n, __x); }
|
|
# 346 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
|
|
template<typename _InputIterator1, typename _InputIterator2,
|
|
typename _ForwardIterator, typename _Allocator>
|
|
inline _ForwardIterator
|
|
__uninitialized_copy_move(_InputIterator1 __first1,
|
|
_InputIterator1 __last1,
|
|
_InputIterator2 __first2,
|
|
_InputIterator2 __last2,
|
|
_ForwardIterator __result,
|
|
_Allocator& __alloc)
|
|
{
|
|
_ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
|
|
__result,
|
|
__alloc);
|
|
try
|
|
{
|
|
return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__result, __mid, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _InputIterator1, typename _InputIterator2,
|
|
typename _ForwardIterator, typename _Allocator>
|
|
inline _ForwardIterator
|
|
__uninitialized_move_copy(_InputIterator1 __first1,
|
|
_InputIterator1 __last1,
|
|
_InputIterator2 __first2,
|
|
_InputIterator2 __last2,
|
|
_ForwardIterator __result,
|
|
_Allocator& __alloc)
|
|
{
|
|
_ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
|
|
__result,
|
|
__alloc);
|
|
try
|
|
{
|
|
return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__result, __mid, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
|
|
typename _Allocator>
|
|
inline _ForwardIterator
|
|
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
|
|
const _Tp& __x, _InputIterator __first,
|
|
_InputIterator __last, _Allocator& __alloc)
|
|
{
|
|
std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
|
|
try
|
|
{
|
|
return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__result, __mid, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
|
|
typename _Allocator>
|
|
inline void
|
|
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
|
|
_ForwardIterator __first2,
|
|
_ForwardIterator __last2, const _Tp& __x,
|
|
_Allocator& __alloc)
|
|
{
|
|
_ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
|
|
__first2,
|
|
__alloc);
|
|
try
|
|
{
|
|
std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__first2, __mid2, __alloc);
|
|
throw;
|
|
}
|
|
}
|
|
# 653 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 3
|
|
|
|
}
|
|
# 64 "/usr/include/c++/4.8.2/vector" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_vector.h" 1 3
|
|
# 66 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
struct _Vector_base
|
|
{
|
|
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
|
|
rebind<_Tp>::other _Tp_alloc_type;
|
|
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
|
|
pointer;
|
|
|
|
struct _Vector_impl
|
|
: public _Tp_alloc_type
|
|
{
|
|
pointer _M_start;
|
|
pointer _M_finish;
|
|
pointer _M_end_of_storage;
|
|
|
|
_Vector_impl()
|
|
: _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
|
|
{ }
|
|
|
|
_Vector_impl(_Tp_alloc_type const& __a)
|
|
: _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
|
|
{ }
|
|
# 101 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void _M_swap_data(_Vector_impl& __x)
|
|
{
|
|
std::swap(_M_start, __x._M_start);
|
|
std::swap(_M_finish, __x._M_finish);
|
|
std::swap(_M_end_of_storage, __x._M_end_of_storage);
|
|
}
|
|
};
|
|
|
|
public:
|
|
typedef _Alloc allocator_type;
|
|
|
|
_Tp_alloc_type&
|
|
_M_get_Tp_allocator()
|
|
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
|
|
|
|
const _Tp_alloc_type&
|
|
_M_get_Tp_allocator() const
|
|
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_get_Tp_allocator()); }
|
|
|
|
_Vector_base()
|
|
: _M_impl() { }
|
|
|
|
_Vector_base(const allocator_type& __a)
|
|
: _M_impl(__a) { }
|
|
|
|
_Vector_base(size_t __n)
|
|
: _M_impl()
|
|
{ _M_create_storage(__n); }
|
|
|
|
_Vector_base(size_t __n, const allocator_type& __a)
|
|
: _M_impl(__a)
|
|
{ _M_create_storage(__n); }
|
|
# 159 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
~_Vector_base()
|
|
{ _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start); }
|
|
|
|
public:
|
|
_Vector_impl _M_impl;
|
|
|
|
pointer
|
|
_M_allocate(size_t __n)
|
|
{ return __n != 0 ? _M_impl.allocate(__n) : 0; }
|
|
|
|
void
|
|
_M_deallocate(pointer __p, size_t __n)
|
|
{
|
|
if (__p)
|
|
_M_impl.deallocate(__p, __n);
|
|
}
|
|
|
|
private:
|
|
void
|
|
_M_create_storage(size_t __n)
|
|
{
|
|
this->_M_impl._M_start = this->_M_allocate(__n);
|
|
this->_M_impl._M_finish = this->_M_impl._M_start;
|
|
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
|
|
}
|
|
};
|
|
# 209 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
|
|
class vector : protected _Vector_base<_Tp, _Alloc>
|
|
{
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
typedef _Vector_base<_Tp, _Alloc> _Base;
|
|
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
|
|
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
|
|
|
|
public:
|
|
typedef _Tp value_type;
|
|
typedef typename _Base::pointer pointer;
|
|
typedef typename _Alloc_traits::const_pointer const_pointer;
|
|
typedef typename _Alloc_traits::reference reference;
|
|
typedef typename _Alloc_traits::const_reference const_reference;
|
|
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
|
|
typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
|
|
const_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Alloc allocator_type;
|
|
|
|
protected:
|
|
using _Base::_M_allocate;
|
|
using _Base::_M_deallocate;
|
|
using _Base::_M_impl;
|
|
using _Base::_M_get_Tp_allocator;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
vector()
|
|
: _Base() { }
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
vector(const allocator_type& __a)
|
|
: _Base(__a) { }
|
|
# 294 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
explicit
|
|
vector(size_type __n, const value_type& __value = value_type(),
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(__n, __a)
|
|
{ _M_fill_initialize(__n, __value); }
|
|
# 310 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
vector(const vector& __x)
|
|
: _Base(__x.size(),
|
|
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
|
|
{ this->_M_impl._M_finish =
|
|
std::__uninitialized_copy_a(__x.begin(), __x.end(),
|
|
this->_M_impl._M_start,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
# 397 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _InputIterator>
|
|
vector(_InputIterator __first, _InputIterator __last,
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(__a)
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_initialize_dispatch(__first, __last, _Integral());
|
|
}
|
|
# 414 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
~vector()
|
|
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator()); }
|
|
# 426 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
vector&
|
|
operator=(const vector& __x);
|
|
# 478 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
assign(size_type __n, const value_type& __val)
|
|
{ _M_fill_assign(__n, __val); }
|
|
# 501 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
assign(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_assign_dispatch(__first, __last, _Integral());
|
|
}
|
|
# 529 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
using _Base::get_allocator;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin()
|
|
{ return iterator(this->_M_impl._M_start); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return const_iterator(this->_M_impl._M_start); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end()
|
|
{ return iterator(this->_M_impl._M_finish); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return const_iterator(this->_M_impl._M_finish); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return reverse_iterator(end()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return const_reverse_iterator(end()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return reverse_iterator(begin()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return const_reverse_iterator(begin()); }
|
|
# 644 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
size_type
|
|
size() const
|
|
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
|
|
# 703 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
resize(size_type __new_size, value_type __x = value_type())
|
|
{
|
|
if (__new_size > size())
|
|
insert(end(), __new_size - size(), __x);
|
|
else if (__new_size < size())
|
|
_M_erase_at_end(this->_M_impl._M_start + __new_size);
|
|
}
|
|
# 724 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
size_type
|
|
capacity() const
|
|
{ return size_type(this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start); }
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
empty() const
|
|
{ return begin() == end(); }
|
|
# 754 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
reserve(size_type __n);
|
|
# 769 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
reference
|
|
operator[](size_type __n)
|
|
{ return *(this->_M_impl._M_start + __n); }
|
|
# 784 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
const_reference
|
|
operator[](size_type __n) const
|
|
{ return *(this->_M_impl._M_start + __n); }
|
|
|
|
protected:
|
|
|
|
void
|
|
_M_range_check(size_type __n) const
|
|
{
|
|
if (__n >= this->size())
|
|
__throw_out_of_range(("vector::_M_range_check"));
|
|
}
|
|
|
|
public:
|
|
# 809 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
reference
|
|
at(size_type __n)
|
|
{
|
|
_M_range_check(__n);
|
|
return (*this)[__n];
|
|
}
|
|
# 827 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
const_reference
|
|
at(size_type __n) const
|
|
{
|
|
_M_range_check(__n);
|
|
return (*this)[__n];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
front()
|
|
{ return *begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
front() const
|
|
{ return *begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
back()
|
|
{ return *(end() - 1); }
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
back() const
|
|
{ return *(end() - 1); }
|
|
# 876 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
pointer
|
|
|
|
data()
|
|
{ return std::__addressof(front()); }
|
|
|
|
|
|
|
|
|
|
const_pointer
|
|
|
|
data() const
|
|
{ return std::__addressof(front()); }
|
|
# 900 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
push_back(const value_type& __x)
|
|
{
|
|
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
|
|
{
|
|
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
|
|
__x);
|
|
++this->_M_impl._M_finish;
|
|
}
|
|
else
|
|
|
|
|
|
|
|
_M_insert_aux(end(), __x);
|
|
|
|
}
|
|
# 936 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
pop_back()
|
|
{
|
|
--this->_M_impl._M_finish;
|
|
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
|
|
}
|
|
# 972 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
iterator
|
|
insert(iterator __position, const value_type& __x);
|
|
# 1022 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
insert(iterator __position, size_type __n, const value_type& __x)
|
|
{ _M_fill_insert(__position, __n, __x); }
|
|
# 1048 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(iterator __position, _InputIterator __first,
|
|
_InputIterator __last)
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_insert_dispatch(__position, __first, __last, _Integral());
|
|
}
|
|
# 1074 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
iterator
|
|
erase(iterator __position);
|
|
# 1095 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
iterator
|
|
erase(iterator __first, iterator __last);
|
|
# 1107 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
swap(vector& __x)
|
|
|
|
|
|
|
|
{
|
|
this->_M_impl._M_swap_data(__x._M_impl);
|
|
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
|
|
__x._M_get_Tp_allocator());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
clear()
|
|
{ _M_erase_at_end(this->_M_impl._M_start); }
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
pointer
|
|
_M_allocate_and_copy(size_type __n,
|
|
_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
pointer __result = this->_M_allocate(__n);
|
|
try
|
|
{
|
|
std::__uninitialized_copy_a(__first, __last, __result,
|
|
_M_get_Tp_allocator());
|
|
return __result;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_deallocate(__result, __n);
|
|
throw;
|
|
}
|
|
}
|
|
# 1159 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
|
|
{
|
|
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
|
|
this->_M_impl._M_end_of_storage =
|
|
this->_M_impl._M_start + static_cast<size_type>(__n);
|
|
_M_fill_initialize(static_cast<size_type>(__n), __value);
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{
|
|
typedef typename std::iterator_traits<_InputIterator>::
|
|
iterator_category _IterCategory;
|
|
_M_range_initialize(__first, __last, _IterCategory());
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_range_initialize(_InputIterator __first,
|
|
_InputIterator __last, std::input_iterator_tag)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
|
|
|
|
|
|
push_back(*__first);
|
|
|
|
}
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_range_initialize(_ForwardIterator __first,
|
|
_ForwardIterator __last, std::forward_iterator_tag)
|
|
{
|
|
const size_type __n = std::distance(__first, __last);
|
|
this->_M_impl._M_start = this->_M_allocate(__n);
|
|
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
|
|
this->_M_impl._M_finish =
|
|
std::__uninitialized_copy_a(__first, __last,
|
|
this->_M_impl._M_start,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
|
|
|
|
|
|
void
|
|
_M_fill_initialize(size_type __n, const value_type& __value)
|
|
{
|
|
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
|
|
}
|
|
# 1237 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
|
|
{ _M_fill_assign(__n, __val); }
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{
|
|
typedef typename std::iterator_traits<_InputIterator>::
|
|
iterator_category _IterCategory;
|
|
_M_assign_aux(__first, __last, _IterCategory());
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_assign_aux(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag);
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag);
|
|
|
|
|
|
|
|
void
|
|
_M_fill_assign(size_type __n, const value_type& __val);
|
|
# 1277 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
|
|
__true_type)
|
|
{ _M_fill_insert(__pos, __n, __val); }
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_insert_dispatch(iterator __pos, _InputIterator __first,
|
|
_InputIterator __last, __false_type)
|
|
{
|
|
typedef typename std::iterator_traits<_InputIterator>::
|
|
iterator_category _IterCategory;
|
|
_M_range_insert(__pos, __first, __last, _IterCategory());
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_range_insert(iterator __pos, _InputIterator __first,
|
|
_InputIterator __last, std::input_iterator_tag);
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_range_insert(iterator __pos, _ForwardIterator __first,
|
|
_ForwardIterator __last, std::forward_iterator_tag);
|
|
|
|
|
|
|
|
void
|
|
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
|
|
# 1322 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
void
|
|
_M_insert_aux(iterator __position, const value_type& __x);
|
|
# 1335 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
size_type
|
|
_M_check_len(size_type __n, const char* __s) const
|
|
{
|
|
if (max_size() - size() < __n)
|
|
__throw_length_error((__s));
|
|
|
|
const size_type __len = size() + std::max(size(), __n);
|
|
return (__len < size() || __len > max_size()) ? max_size() : __len;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_erase_at_end(pointer __pos)
|
|
{
|
|
std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __pos;
|
|
}
|
|
# 1389 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
};
|
|
# 1402 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
|
|
{ return (__x.size() == __y.size()
|
|
&& std::equal(__x.begin(), __x.end(), __y.begin())); }
|
|
# 1419 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
|
|
{ return std::lexicographical_compare(__x.begin(), __x.end(),
|
|
__y.begin(), __y.end()); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline void
|
|
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
}
|
|
# 65 "/usr/include/c++/4.8.2/vector" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 1 3
|
|
# 63 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
typedef unsigned long _Bit_type;
|
|
enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
|
|
|
|
struct _Bit_reference
|
|
{
|
|
_Bit_type * _M_p;
|
|
_Bit_type _M_mask;
|
|
|
|
_Bit_reference(_Bit_type * __x, _Bit_type __y)
|
|
: _M_p(__x), _M_mask(__y) { }
|
|
|
|
_Bit_reference() : _M_p(0), _M_mask(0) { }
|
|
|
|
operator bool() const
|
|
{ return !!(*_M_p & _M_mask); }
|
|
|
|
_Bit_reference&
|
|
operator=(bool __x)
|
|
{
|
|
if (__x)
|
|
*_M_p |= _M_mask;
|
|
else
|
|
*_M_p &= ~_M_mask;
|
|
return *this;
|
|
}
|
|
|
|
_Bit_reference&
|
|
operator=(const _Bit_reference& __x)
|
|
{ return *this = bool(__x); }
|
|
|
|
bool
|
|
operator==(const _Bit_reference& __x) const
|
|
{ return bool(*this) == bool(__x); }
|
|
|
|
bool
|
|
operator<(const _Bit_reference& __x) const
|
|
{ return !bool(*this) && bool(__x); }
|
|
|
|
void
|
|
flip()
|
|
{ *_M_p ^= _M_mask; }
|
|
};
|
|
# 136 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
struct _Bit_iterator_base
|
|
: public std::iterator<std::random_access_iterator_tag, bool>
|
|
{
|
|
_Bit_type * _M_p;
|
|
unsigned int _M_offset;
|
|
|
|
_Bit_iterator_base(_Bit_type * __x, unsigned int __y)
|
|
: _M_p(__x), _M_offset(__y) { }
|
|
|
|
void
|
|
_M_bump_up()
|
|
{
|
|
if (_M_offset++ == int(_S_word_bit) - 1)
|
|
{
|
|
_M_offset = 0;
|
|
++_M_p;
|
|
}
|
|
}
|
|
|
|
void
|
|
_M_bump_down()
|
|
{
|
|
if (_M_offset-- == 0)
|
|
{
|
|
_M_offset = int(_S_word_bit) - 1;
|
|
--_M_p;
|
|
}
|
|
}
|
|
|
|
void
|
|
_M_incr(ptrdiff_t __i)
|
|
{
|
|
difference_type __n = __i + _M_offset;
|
|
_M_p += __n / int(_S_word_bit);
|
|
__n = __n % int(_S_word_bit);
|
|
if (__n < 0)
|
|
{
|
|
__n += int(_S_word_bit);
|
|
--_M_p;
|
|
}
|
|
_M_offset = static_cast<unsigned int>(__n);
|
|
}
|
|
|
|
bool
|
|
operator==(const _Bit_iterator_base& __i) const
|
|
{ return _M_p == __i._M_p && _M_offset == __i._M_offset; }
|
|
|
|
bool
|
|
operator<(const _Bit_iterator_base& __i) const
|
|
{
|
|
return _M_p < __i._M_p
|
|
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
|
|
}
|
|
|
|
bool
|
|
operator!=(const _Bit_iterator_base& __i) const
|
|
{ return !(*this == __i); }
|
|
|
|
bool
|
|
operator>(const _Bit_iterator_base& __i) const
|
|
{ return __i < *this; }
|
|
|
|
bool
|
|
operator<=(const _Bit_iterator_base& __i) const
|
|
{ return !(__i < *this); }
|
|
|
|
bool
|
|
operator>=(const _Bit_iterator_base& __i) const
|
|
{ return !(*this < __i); }
|
|
};
|
|
|
|
inline ptrdiff_t
|
|
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
|
|
{
|
|
return (int(_S_word_bit) * (__x._M_p - __y._M_p)
|
|
+ __x._M_offset - __y._M_offset);
|
|
}
|
|
|
|
struct _Bit_iterator : public _Bit_iterator_base
|
|
{
|
|
typedef _Bit_reference reference;
|
|
typedef _Bit_reference* pointer;
|
|
typedef _Bit_iterator iterator;
|
|
|
|
_Bit_iterator() : _Bit_iterator_base(0, 0) { }
|
|
|
|
_Bit_iterator(_Bit_type * __x, unsigned int __y)
|
|
: _Bit_iterator_base(__x, __y) { }
|
|
|
|
reference
|
|
operator*() const
|
|
{ return reference(_M_p, 1UL << _M_offset); }
|
|
|
|
iterator&
|
|
operator++()
|
|
{
|
|
_M_bump_up();
|
|
return *this;
|
|
}
|
|
|
|
iterator
|
|
operator++(int)
|
|
{
|
|
iterator __tmp = *this;
|
|
_M_bump_up();
|
|
return __tmp;
|
|
}
|
|
|
|
iterator&
|
|
operator--()
|
|
{
|
|
_M_bump_down();
|
|
return *this;
|
|
}
|
|
|
|
iterator
|
|
operator--(int)
|
|
{
|
|
iterator __tmp = *this;
|
|
_M_bump_down();
|
|
return __tmp;
|
|
}
|
|
|
|
iterator&
|
|
operator+=(difference_type __i)
|
|
{
|
|
_M_incr(__i);
|
|
return *this;
|
|
}
|
|
|
|
iterator&
|
|
operator-=(difference_type __i)
|
|
{
|
|
*this += -__i;
|
|
return *this;
|
|
}
|
|
|
|
iterator
|
|
operator+(difference_type __i) const
|
|
{
|
|
iterator __tmp = *this;
|
|
return __tmp += __i;
|
|
}
|
|
|
|
iterator
|
|
operator-(difference_type __i) const
|
|
{
|
|
iterator __tmp = *this;
|
|
return __tmp -= __i;
|
|
}
|
|
|
|
reference
|
|
operator[](difference_type __i) const
|
|
{ return *(*this + __i); }
|
|
};
|
|
|
|
inline _Bit_iterator
|
|
operator+(ptrdiff_t __n, const _Bit_iterator& __x)
|
|
{ return __x + __n; }
|
|
|
|
struct _Bit_const_iterator : public _Bit_iterator_base
|
|
{
|
|
typedef bool reference;
|
|
typedef bool const_reference;
|
|
typedef const bool* pointer;
|
|
typedef _Bit_const_iterator const_iterator;
|
|
|
|
_Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
|
|
|
|
_Bit_const_iterator(_Bit_type * __x, unsigned int __y)
|
|
: _Bit_iterator_base(__x, __y) { }
|
|
|
|
_Bit_const_iterator(const _Bit_iterator& __x)
|
|
: _Bit_iterator_base(__x._M_p, __x._M_offset) { }
|
|
|
|
const_reference
|
|
operator*() const
|
|
{ return _Bit_reference(_M_p, 1UL << _M_offset); }
|
|
|
|
const_iterator&
|
|
operator++()
|
|
{
|
|
_M_bump_up();
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator++(int)
|
|
{
|
|
const_iterator __tmp = *this;
|
|
_M_bump_up();
|
|
return __tmp;
|
|
}
|
|
|
|
const_iterator&
|
|
operator--()
|
|
{
|
|
_M_bump_down();
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator--(int)
|
|
{
|
|
const_iterator __tmp = *this;
|
|
_M_bump_down();
|
|
return __tmp;
|
|
}
|
|
|
|
const_iterator&
|
|
operator+=(difference_type __i)
|
|
{
|
|
_M_incr(__i);
|
|
return *this;
|
|
}
|
|
|
|
const_iterator&
|
|
operator-=(difference_type __i)
|
|
{
|
|
*this += -__i;
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator+(difference_type __i) const
|
|
{
|
|
const_iterator __tmp = *this;
|
|
return __tmp += __i;
|
|
}
|
|
|
|
const_iterator
|
|
operator-(difference_type __i) const
|
|
{
|
|
const_iterator __tmp = *this;
|
|
return __tmp -= __i;
|
|
}
|
|
|
|
const_reference
|
|
operator[](difference_type __i) const
|
|
{ return *(*this + __i); }
|
|
};
|
|
|
|
inline _Bit_const_iterator
|
|
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
|
|
{ return __x + __n; }
|
|
|
|
inline void
|
|
__fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
*__first = __x;
|
|
}
|
|
|
|
inline void
|
|
fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
|
|
{
|
|
if (__first._M_p != __last._M_p)
|
|
{
|
|
std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
|
|
__fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
|
|
__fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
|
|
}
|
|
else
|
|
__fill_bvector(__first, __last, __x);
|
|
}
|
|
|
|
template<typename _Alloc>
|
|
struct _Bvector_base
|
|
{
|
|
typedef typename _Alloc::template rebind<_Bit_type>::other
|
|
_Bit_alloc_type;
|
|
|
|
struct _Bvector_impl
|
|
: public _Bit_alloc_type
|
|
{
|
|
_Bit_iterator _M_start;
|
|
_Bit_iterator _M_finish;
|
|
_Bit_type* _M_end_of_storage;
|
|
|
|
_Bvector_impl()
|
|
: _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
|
|
{ }
|
|
|
|
_Bvector_impl(const _Bit_alloc_type& __a)
|
|
: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
public:
|
|
typedef _Alloc allocator_type;
|
|
|
|
_Bit_alloc_type&
|
|
_M_get_Bit_allocator()
|
|
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
|
|
|
|
const _Bit_alloc_type&
|
|
_M_get_Bit_allocator() const
|
|
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_get_Bit_allocator()); }
|
|
|
|
_Bvector_base()
|
|
: _M_impl() { }
|
|
|
|
_Bvector_base(const allocator_type& __a)
|
|
: _M_impl(__a) { }
|
|
# 465 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
~_Bvector_base()
|
|
{ this->_M_deallocate(); }
|
|
|
|
protected:
|
|
_Bvector_impl _M_impl;
|
|
|
|
_Bit_type*
|
|
_M_allocate(size_t __n)
|
|
{ return _M_impl.allocate(_S_nword(__n)); }
|
|
|
|
void
|
|
_M_deallocate()
|
|
{
|
|
if (_M_impl._M_start._M_p)
|
|
_M_impl.deallocate(_M_impl._M_start._M_p,
|
|
_M_impl._M_end_of_storage - _M_impl._M_start._M_p);
|
|
}
|
|
|
|
static size_t
|
|
_S_nword(size_t __n)
|
|
{ return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
|
|
};
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 517 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
template<typename _Alloc>
|
|
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
|
|
{
|
|
typedef _Bvector_base<_Alloc> _Base;
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
typedef bool value_type;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Bit_reference reference;
|
|
typedef bool const_reference;
|
|
typedef _Bit_reference* pointer;
|
|
typedef const bool* const_pointer;
|
|
typedef _Bit_iterator iterator;
|
|
typedef _Bit_const_iterator const_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef _Alloc allocator_type;
|
|
|
|
allocator_type get_allocator() const
|
|
{ return _Base::get_allocator(); }
|
|
|
|
protected:
|
|
using _Base::_M_allocate;
|
|
using _Base::_M_deallocate;
|
|
using _Base::_S_nword;
|
|
using _Base::_M_get_Bit_allocator;
|
|
|
|
public:
|
|
vector()
|
|
: _Base() { }
|
|
|
|
explicit
|
|
vector(const allocator_type& __a)
|
|
: _Base(__a) { }
|
|
# 572 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
explicit
|
|
vector(size_type __n, const bool& __value = bool(),
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(__a)
|
|
{
|
|
_M_initialize(__n);
|
|
std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
|
|
__value ? ~0 : 0);
|
|
}
|
|
|
|
|
|
vector(const vector& __x)
|
|
: _Base(__x._M_get_Bit_allocator())
|
|
{
|
|
_M_initialize(__x.size());
|
|
_M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
|
|
}
|
|
# 611 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
template<typename _InputIterator>
|
|
vector(_InputIterator __first, _InputIterator __last,
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(__a)
|
|
{
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_initialize_dispatch(__first, __last, _Integral());
|
|
}
|
|
|
|
|
|
~vector() { }
|
|
|
|
vector&
|
|
operator=(const vector& __x)
|
|
{
|
|
if (&__x == this)
|
|
return *this;
|
|
if (__x.size() > capacity())
|
|
{
|
|
this->_M_deallocate();
|
|
_M_initialize(__x.size());
|
|
}
|
|
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
|
|
begin());
|
|
return *this;
|
|
}
|
|
# 661 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
void
|
|
assign(size_type __n, const bool& __x)
|
|
{ _M_fill_assign(__n, __x); }
|
|
# 672 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
assign(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_assign_dispatch(__first, __last, _Integral());
|
|
}
|
|
# 687 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
iterator
|
|
begin()
|
|
{ return this->_M_impl._M_start; }
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return this->_M_impl._M_start; }
|
|
|
|
iterator
|
|
end()
|
|
{ return this->_M_impl._M_finish; }
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return this->_M_impl._M_finish; }
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return reverse_iterator(end()); }
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return const_reverse_iterator(end()); }
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return reverse_iterator(begin()); }
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return const_reverse_iterator(begin()); }
|
|
# 737 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
size_type
|
|
size() const
|
|
{ return size_type(end() - begin()); }
|
|
|
|
size_type
|
|
max_size() const
|
|
{
|
|
const size_type __isize =
|
|
__gnu_cxx::__numeric_traits<difference_type>::__max
|
|
- int(_S_word_bit) + 1;
|
|
const size_type __asize = _M_get_Bit_allocator().max_size();
|
|
return (__asize <= __isize / int(_S_word_bit)
|
|
? __asize * int(_S_word_bit) : __isize);
|
|
}
|
|
|
|
size_type
|
|
capacity() const
|
|
{ return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
|
|
- begin()); }
|
|
|
|
bool
|
|
empty() const
|
|
{ return begin() == end(); }
|
|
|
|
reference
|
|
operator[](size_type __n)
|
|
{
|
|
return *iterator(this->_M_impl._M_start._M_p
|
|
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
|
|
}
|
|
|
|
const_reference
|
|
operator[](size_type __n) const
|
|
{
|
|
return *const_iterator(this->_M_impl._M_start._M_p
|
|
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
|
|
}
|
|
|
|
protected:
|
|
void
|
|
_M_range_check(size_type __n) const
|
|
{
|
|
if (__n >= this->size())
|
|
__throw_out_of_range(("vector<bool>::_M_range_check"));
|
|
}
|
|
|
|
public:
|
|
reference
|
|
at(size_type __n)
|
|
{ _M_range_check(__n); return (*this)[__n]; }
|
|
|
|
const_reference
|
|
at(size_type __n) const
|
|
{ _M_range_check(__n); return (*this)[__n]; }
|
|
|
|
void
|
|
reserve(size_type __n)
|
|
{
|
|
if (__n > max_size())
|
|
__throw_length_error(("vector::reserve"));
|
|
if (capacity() < __n)
|
|
_M_reallocate(__n);
|
|
}
|
|
|
|
reference
|
|
front()
|
|
{ return *begin(); }
|
|
|
|
const_reference
|
|
front() const
|
|
{ return *begin(); }
|
|
|
|
reference
|
|
back()
|
|
{ return *(end() - 1); }
|
|
|
|
const_reference
|
|
back() const
|
|
{ return *(end() - 1); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
data() { }
|
|
|
|
void
|
|
push_back(bool __x)
|
|
{
|
|
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
|
|
*this->_M_impl._M_finish++ = __x;
|
|
else
|
|
_M_insert_aux(end(), __x);
|
|
}
|
|
|
|
void
|
|
swap(vector& __x)
|
|
{
|
|
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
|
|
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
|
|
std::swap(this->_M_impl._M_end_of_storage,
|
|
__x._M_impl._M_end_of_storage);
|
|
|
|
|
|
|
|
std::__alloc_swap<typename _Base::_Bit_alloc_type>::
|
|
_S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
|
|
}
|
|
|
|
|
|
static void
|
|
swap(reference __x, reference __y)
|
|
{
|
|
bool __tmp = __x;
|
|
__x = __y;
|
|
__y = __tmp;
|
|
}
|
|
|
|
iterator
|
|
insert(iterator __position, const bool& __x = bool())
|
|
{
|
|
const difference_type __n = __position - begin();
|
|
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
|
|
&& __position == end())
|
|
*this->_M_impl._M_finish++ = __x;
|
|
else
|
|
_M_insert_aux(__position, __x);
|
|
return begin() + __n;
|
|
}
|
|
# 877 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(iterator __position,
|
|
_InputIterator __first, _InputIterator __last)
|
|
{
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_insert_dispatch(__position, __first, __last, _Integral());
|
|
}
|
|
|
|
|
|
void
|
|
insert(iterator __position, size_type __n, const bool& __x)
|
|
{ _M_fill_insert(__position, __n, __x); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
pop_back()
|
|
{ --this->_M_impl._M_finish; }
|
|
|
|
iterator
|
|
erase(iterator __position)
|
|
{
|
|
if (__position + 1 != end())
|
|
std::copy(__position + 1, end(), __position);
|
|
--this->_M_impl._M_finish;
|
|
return __position;
|
|
}
|
|
|
|
iterator
|
|
erase(iterator __first, iterator __last)
|
|
{
|
|
if (__first != __last)
|
|
_M_erase_at_end(std::copy(__last, end(), __first));
|
|
return __first;
|
|
}
|
|
|
|
void
|
|
resize(size_type __new_size, bool __x = bool())
|
|
{
|
|
if (__new_size < size())
|
|
_M_erase_at_end(begin() + difference_type(__new_size));
|
|
else
|
|
insert(end(), __new_size - size(), __x);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
flip()
|
|
{
|
|
for (_Bit_type * __p = this->_M_impl._M_start._M_p;
|
|
__p != this->_M_impl._M_end_of_storage; ++__p)
|
|
*__p = ~*__p;
|
|
}
|
|
|
|
void
|
|
clear()
|
|
{ _M_erase_at_end(begin()); }
|
|
|
|
|
|
protected:
|
|
|
|
iterator
|
|
_M_copy_aligned(const_iterator __first, const_iterator __last,
|
|
iterator __result)
|
|
{
|
|
_Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
|
|
return std::copy(const_iterator(__last._M_p, 0), __last,
|
|
iterator(__q, 0));
|
|
}
|
|
|
|
void
|
|
_M_initialize(size_type __n)
|
|
{
|
|
_Bit_type* __q = this->_M_allocate(__n);
|
|
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
|
|
this->_M_impl._M_start = iterator(__q, 0);
|
|
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
|
|
}
|
|
|
|
void
|
|
_M_reallocate(size_type __n);
|
|
# 977 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
|
|
{
|
|
_M_initialize(static_cast<size_type>(__n));
|
|
std::fill(this->_M_impl._M_start._M_p,
|
|
this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
|
|
}
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{ _M_initialize_range(__first, __last,
|
|
std::__iterator_category(__first)); }
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_initialize_range(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
}
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag)
|
|
{
|
|
const size_type __n = std::distance(__first, __last);
|
|
_M_initialize(__n);
|
|
std::copy(__first, __last, this->_M_impl._M_start);
|
|
}
|
|
|
|
|
|
|
|
template<typename _Integer>
|
|
void
|
|
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
|
|
{ _M_fill_assign(__n, __val); }
|
|
|
|
template<class _InputIterator>
|
|
void
|
|
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{ _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
|
|
|
|
void
|
|
_M_fill_assign(size_t __n, bool __x)
|
|
{
|
|
if (__n > size())
|
|
{
|
|
std::fill(this->_M_impl._M_start._M_p,
|
|
this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
|
|
insert(end(), __n - size(), __x);
|
|
}
|
|
else
|
|
{
|
|
_M_erase_at_end(begin() + __n);
|
|
std::fill(this->_M_impl._M_start._M_p,
|
|
this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
|
|
}
|
|
}
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_assign_aux(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag)
|
|
{
|
|
iterator __cur = begin();
|
|
for (; __first != __last && __cur != end(); ++__cur, ++__first)
|
|
*__cur = *__first;
|
|
if (__first == __last)
|
|
_M_erase_at_end(__cur);
|
|
else
|
|
insert(end(), __first, __last);
|
|
}
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag)
|
|
{
|
|
const size_type __len = std::distance(__first, __last);
|
|
if (__len < size())
|
|
_M_erase_at_end(std::copy(__first, __last, begin()));
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, size());
|
|
std::copy(__first, __mid, begin());
|
|
insert(end(), __mid, __last);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Integer>
|
|
void
|
|
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
|
|
__true_type)
|
|
{ _M_fill_insert(__pos, __n, __x); }
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_insert_dispatch(iterator __pos,
|
|
_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{ _M_insert_range(__pos, __first, __last,
|
|
std::__iterator_category(__first)); }
|
|
|
|
void
|
|
_M_fill_insert(iterator __position, size_type __n, bool __x);
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_insert_range(iterator __pos, _InputIterator __first,
|
|
_InputIterator __last, std::input_iterator_tag)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
{
|
|
__pos = insert(__pos, *__first);
|
|
++__pos;
|
|
}
|
|
}
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_insert_range(iterator __position, _ForwardIterator __first,
|
|
_ForwardIterator __last, std::forward_iterator_tag);
|
|
|
|
void
|
|
_M_insert_aux(iterator __position, bool __x);
|
|
|
|
size_type
|
|
_M_check_len(size_type __n, const char* __s) const
|
|
{
|
|
if (max_size() - size() < __n)
|
|
__throw_length_error((__s));
|
|
|
|
const size_type __len = size() + std::max(size(), __n);
|
|
return (__len < size() || __len > max_size()) ? max_size() : __len;
|
|
}
|
|
|
|
void
|
|
_M_erase_at_end(iterator __pos)
|
|
{ this->_M_impl._M_finish = __pos; }
|
|
};
|
|
|
|
|
|
}
|
|
# 66 "/usr/include/c++/4.8.2/vector" 2 3
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/vector.tcc" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
reserve(size_type __n)
|
|
{
|
|
if (__n > this->max_size())
|
|
__throw_length_error(("vector::reserve"));
|
|
if (this->capacity() < __n)
|
|
{
|
|
const size_type __old_size = size();
|
|
pointer __tmp = _M_allocate_and_copy(__n,
|
|
(this->_M_impl._M_start),
|
|
(this->_M_impl._M_finish));
|
|
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(this->_M_impl._M_start,
|
|
this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start);
|
|
this->_M_impl._M_start = __tmp;
|
|
this->_M_impl._M_finish = __tmp + __old_size;
|
|
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
|
|
}
|
|
}
|
|
# 105 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
typename vector<_Tp, _Alloc>::iterator
|
|
vector<_Tp, _Alloc>::
|
|
insert(iterator __position, const value_type& __x)
|
|
{
|
|
const size_type __n = __position - begin();
|
|
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
|
|
&& __position == end())
|
|
{
|
|
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
|
|
++this->_M_impl._M_finish;
|
|
}
|
|
else
|
|
{
|
|
# 127 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
_M_insert_aux(__position, __x);
|
|
}
|
|
return iterator(this->_M_impl._M_start + __n);
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
typename vector<_Tp, _Alloc>::iterator
|
|
vector<_Tp, _Alloc>::
|
|
erase(iterator __position)
|
|
{
|
|
if (__position + 1 != end())
|
|
std::copy(__position + 1, end(), __position);
|
|
--this->_M_impl._M_finish;
|
|
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
|
|
return __position;
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
typename vector<_Tp, _Alloc>::iterator
|
|
vector<_Tp, _Alloc>::
|
|
erase(iterator __first, iterator __last)
|
|
{
|
|
if (__first != __last)
|
|
{
|
|
if (__last != end())
|
|
std::copy(__last, end(), __first);
|
|
_M_erase_at_end(__first.base() + (end() - __last));
|
|
}
|
|
return __first;
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
vector<_Tp, _Alloc>&
|
|
vector<_Tp, _Alloc>::
|
|
operator=(const vector<_Tp, _Alloc>& __x)
|
|
{
|
|
if (&__x != this)
|
|
{
|
|
# 184 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
const size_type __xlen = __x.size();
|
|
if (__xlen > capacity())
|
|
{
|
|
pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
|
|
__x.end());
|
|
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(this->_M_impl._M_start,
|
|
this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start);
|
|
this->_M_impl._M_start = __tmp;
|
|
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
|
|
}
|
|
else if (size() >= __xlen)
|
|
{
|
|
std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
|
|
end(), _M_get_Tp_allocator());
|
|
}
|
|
else
|
|
{
|
|
std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
|
|
this->_M_impl._M_start);
|
|
std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
|
|
__x._M_impl._M_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_fill_assign(size_t __n, const value_type& __val)
|
|
{
|
|
if (__n > capacity())
|
|
{
|
|
vector __tmp(__n, __val, _M_get_Tp_allocator());
|
|
__tmp.swap(*this);
|
|
}
|
|
else if (__n > size())
|
|
{
|
|
std::fill(begin(), end(), __val);
|
|
std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
|
|
__n - size(), __val,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __n - size();
|
|
}
|
|
else
|
|
_M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template<typename _InputIterator>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_assign_aux(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag)
|
|
{
|
|
pointer __cur(this->_M_impl._M_start);
|
|
for (; __first != __last && __cur != this->_M_impl._M_finish;
|
|
++__cur, ++__first)
|
|
*__cur = *__first;
|
|
if (__first == __last)
|
|
_M_erase_at_end(__cur);
|
|
else
|
|
insert(end(), __first, __last);
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template<typename _ForwardIterator>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag)
|
|
{
|
|
const size_type __len = std::distance(__first, __last);
|
|
|
|
if (__len > capacity())
|
|
{
|
|
pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
|
|
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(this->_M_impl._M_start,
|
|
this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start);
|
|
this->_M_impl._M_start = __tmp;
|
|
this->_M_impl._M_finish = this->_M_impl._M_start + __len;
|
|
this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
|
|
}
|
|
else if (size() >= __len)
|
|
_M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, size());
|
|
std::copy(__first, __mid, this->_M_impl._M_start);
|
|
this->_M_impl._M_finish =
|
|
std::__uninitialized_copy_a(__mid, __last,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
}
|
|
# 316 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_insert_aux(iterator __position, const _Tp& __x)
|
|
|
|
{
|
|
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
|
|
{
|
|
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
|
|
(*(this->_M_impl._M_finish - 1))
|
|
);
|
|
++this->_M_impl._M_finish;
|
|
|
|
_Tp __x_copy = __x;
|
|
|
|
std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
|
|
|
|
;
|
|
|
|
*__position = __x_copy;
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
const size_type __len =
|
|
_M_check_len(size_type(1), "vector::_M_insert_aux");
|
|
const size_type __elems_before = __position - begin();
|
|
pointer __new_start(this->_M_allocate(__len));
|
|
pointer __new_finish(__new_start);
|
|
try
|
|
{
|
|
|
|
|
|
|
|
|
|
_Alloc_traits::construct(this->_M_impl,
|
|
__new_start + __elems_before,
|
|
|
|
|
|
|
|
__x);
|
|
|
|
__new_finish = 0;
|
|
|
|
__new_finish
|
|
= std::__uninitialized_move_if_noexcept_a
|
|
(this->_M_impl._M_start, __position.base(),
|
|
__new_start, _M_get_Tp_allocator());
|
|
|
|
++__new_finish;
|
|
|
|
__new_finish
|
|
= std::__uninitialized_move_if_noexcept_a
|
|
(__position.base(), this->_M_impl._M_finish,
|
|
__new_finish, _M_get_Tp_allocator());
|
|
}
|
|
catch(...)
|
|
{
|
|
if (!__new_finish)
|
|
_Alloc_traits::destroy(this->_M_impl,
|
|
__new_start + __elems_before);
|
|
else
|
|
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
|
|
_M_deallocate(__new_start, __len);
|
|
throw;
|
|
}
|
|
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(this->_M_impl._M_start,
|
|
this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start);
|
|
this->_M_impl._M_start = __new_start;
|
|
this->_M_impl._M_finish = __new_finish;
|
|
this->_M_impl._M_end_of_storage = __new_start + __len;
|
|
}
|
|
}
|
|
# 439 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_fill_insert(iterator __position, size_type __n, const value_type& __x)
|
|
{
|
|
if (__n != 0)
|
|
{
|
|
if (size_type(this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_finish) >= __n)
|
|
{
|
|
value_type __x_copy = __x;
|
|
const size_type __elems_after = end() - __position;
|
|
pointer __old_finish(this->_M_impl._M_finish);
|
|
if (__elems_after > __n)
|
|
{
|
|
std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
|
|
this->_M_impl._M_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __n;
|
|
std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
|
|
;
|
|
std::fill(__position.base(), __position.base() + __n,
|
|
__x_copy);
|
|
}
|
|
else
|
|
{
|
|
std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
|
|
__n - __elems_after,
|
|
__x_copy,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __n - __elems_after;
|
|
std::__uninitialized_move_a(__position.base(), __old_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __elems_after;
|
|
std::fill(__position.base(), __old_finish, __x_copy);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const size_type __len =
|
|
_M_check_len(__n, "vector::_M_fill_insert");
|
|
const size_type __elems_before = __position - begin();
|
|
pointer __new_start(this->_M_allocate(__len));
|
|
pointer __new_finish(__new_start);
|
|
try
|
|
{
|
|
|
|
std::__uninitialized_fill_n_a(__new_start + __elems_before,
|
|
__n, __x,
|
|
_M_get_Tp_allocator());
|
|
__new_finish = 0;
|
|
|
|
__new_finish
|
|
= std::__uninitialized_move_if_noexcept_a
|
|
(this->_M_impl._M_start, __position.base(),
|
|
__new_start, _M_get_Tp_allocator());
|
|
|
|
__new_finish += __n;
|
|
|
|
__new_finish
|
|
= std::__uninitialized_move_if_noexcept_a
|
|
(__position.base(), this->_M_impl._M_finish,
|
|
__new_finish, _M_get_Tp_allocator());
|
|
}
|
|
catch(...)
|
|
{
|
|
if (!__new_finish)
|
|
std::_Destroy(__new_start + __elems_before,
|
|
__new_start + __elems_before + __n,
|
|
_M_get_Tp_allocator());
|
|
else
|
|
std::_Destroy(__new_start, __new_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(__new_start, __len);
|
|
throw;
|
|
}
|
|
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(this->_M_impl._M_start,
|
|
this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start);
|
|
this->_M_impl._M_start = __new_start;
|
|
this->_M_impl._M_finish = __new_finish;
|
|
this->_M_impl._M_end_of_storage = __new_start + __len;
|
|
}
|
|
}
|
|
}
|
|
# 591 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
template<typename _InputIterator>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_range_insert(iterator __pos, _InputIterator __first,
|
|
_InputIterator __last, std::input_iterator_tag)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
{
|
|
__pos = insert(__pos, *__first);
|
|
++__pos;
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template<typename _ForwardIterator>
|
|
void
|
|
vector<_Tp, _Alloc>::
|
|
_M_range_insert(iterator __position, _ForwardIterator __first,
|
|
_ForwardIterator __last, std::forward_iterator_tag)
|
|
{
|
|
if (__first != __last)
|
|
{
|
|
const size_type __n = std::distance(__first, __last);
|
|
if (size_type(this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_finish) >= __n)
|
|
{
|
|
const size_type __elems_after = end() - __position;
|
|
pointer __old_finish(this->_M_impl._M_finish);
|
|
if (__elems_after > __n)
|
|
{
|
|
std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
|
|
this->_M_impl._M_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __n;
|
|
std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
|
|
;
|
|
std::copy(__first, __last, __position);
|
|
}
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, __elems_after);
|
|
std::__uninitialized_copy_a(__mid, __last,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __n - __elems_after;
|
|
std::__uninitialized_move_a(__position.base(),
|
|
__old_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish += __elems_after;
|
|
std::copy(__first, __mid, __position);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const size_type __len =
|
|
_M_check_len(__n, "vector::_M_range_insert");
|
|
pointer __new_start(this->_M_allocate(__len));
|
|
pointer __new_finish(__new_start);
|
|
try
|
|
{
|
|
__new_finish
|
|
= std::__uninitialized_move_if_noexcept_a
|
|
(this->_M_impl._M_start, __position.base(),
|
|
__new_start, _M_get_Tp_allocator());
|
|
__new_finish
|
|
= std::__uninitialized_copy_a(__first, __last,
|
|
__new_finish,
|
|
_M_get_Tp_allocator());
|
|
__new_finish
|
|
= std::__uninitialized_move_if_noexcept_a
|
|
(__position.base(), this->_M_impl._M_finish,
|
|
__new_finish, _M_get_Tp_allocator());
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(__new_start, __new_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(__new_start, __len);
|
|
throw;
|
|
}
|
|
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
_M_deallocate(this->_M_impl._M_start,
|
|
this->_M_impl._M_end_of_storage
|
|
- this->_M_impl._M_start);
|
|
this->_M_impl._M_start = __new_start;
|
|
this->_M_impl._M_finish = __new_finish;
|
|
this->_M_impl._M_end_of_storage = __new_start + __len;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
template<typename _Alloc>
|
|
void
|
|
vector<bool, _Alloc>::
|
|
_M_reallocate(size_type __n)
|
|
{
|
|
_Bit_type* __q = this->_M_allocate(__n);
|
|
this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
|
|
iterator(__q, 0));
|
|
this->_M_deallocate();
|
|
this->_M_impl._M_start = iterator(__q, 0);
|
|
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
|
|
}
|
|
|
|
template<typename _Alloc>
|
|
void
|
|
vector<bool, _Alloc>::
|
|
_M_fill_insert(iterator __position, size_type __n, bool __x)
|
|
{
|
|
if (__n == 0)
|
|
return;
|
|
if (capacity() - size() >= __n)
|
|
{
|
|
std::copy_backward(__position, end(),
|
|
this->_M_impl._M_finish + difference_type(__n));
|
|
std::fill(__position, __position + difference_type(__n), __x);
|
|
this->_M_impl._M_finish += difference_type(__n);
|
|
}
|
|
else
|
|
{
|
|
const size_type __len =
|
|
_M_check_len(__n, "vector<bool>::_M_fill_insert");
|
|
_Bit_type * __q = this->_M_allocate(__len);
|
|
iterator __i = _M_copy_aligned(begin(), __position,
|
|
iterator(__q, 0));
|
|
std::fill(__i, __i + difference_type(__n), __x);
|
|
this->_M_impl._M_finish = std::copy(__position, end(),
|
|
__i + difference_type(__n));
|
|
this->_M_deallocate();
|
|
this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
|
|
this->_M_impl._M_start = iterator(__q, 0);
|
|
}
|
|
}
|
|
|
|
template<typename _Alloc>
|
|
template<typename _ForwardIterator>
|
|
void
|
|
vector<bool, _Alloc>::
|
|
_M_insert_range(iterator __position, _ForwardIterator __first,
|
|
_ForwardIterator __last, std::forward_iterator_tag)
|
|
{
|
|
if (__first != __last)
|
|
{
|
|
size_type __n = std::distance(__first, __last);
|
|
if (capacity() - size() >= __n)
|
|
{
|
|
std::copy_backward(__position, end(),
|
|
this->_M_impl._M_finish
|
|
+ difference_type(__n));
|
|
std::copy(__first, __last, __position);
|
|
this->_M_impl._M_finish += difference_type(__n);
|
|
}
|
|
else
|
|
{
|
|
const size_type __len =
|
|
_M_check_len(__n, "vector<bool>::_M_insert_range");
|
|
_Bit_type * __q = this->_M_allocate(__len);
|
|
iterator __i = _M_copy_aligned(begin(), __position,
|
|
iterator(__q, 0));
|
|
__i = std::copy(__first, __last, __i);
|
|
this->_M_impl._M_finish = std::copy(__position, end(), __i);
|
|
this->_M_deallocate();
|
|
this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
|
|
this->_M_impl._M_start = iterator(__q, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename _Alloc>
|
|
void
|
|
vector<bool, _Alloc>::
|
|
_M_insert_aux(iterator __position, bool __x)
|
|
{
|
|
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
|
|
{
|
|
std::copy_backward(__position, this->_M_impl._M_finish,
|
|
this->_M_impl._M_finish + 1);
|
|
*__position = __x;
|
|
++this->_M_impl._M_finish;
|
|
}
|
|
else
|
|
{
|
|
const size_type __len =
|
|
_M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
|
|
_Bit_type * __q = this->_M_allocate(__len);
|
|
iterator __i = _M_copy_aligned(begin(), __position,
|
|
iterator(__q, 0));
|
|
*__i++ = __x;
|
|
this->_M_impl._M_finish = std::copy(__position, end(), __i);
|
|
this->_M_deallocate();
|
|
this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
|
|
this->_M_impl._M_start = iterator(__q, 0);
|
|
}
|
|
}
|
|
# 811 "/usr/include/c++/4.8.2/bits/vector.tcc" 3
|
|
|
|
}
|
|
# 70 "/usr/include/c++/4.8.2/vector" 2 3
|
|
# 12 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/c++/4.8.2/queue" 1 3
|
|
# 58 "/usr/include/c++/4.8.2/queue" 3
|
|
|
|
# 59 "/usr/include/c++/4.8.2/queue" 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/deque" 1 3
|
|
# 58 "/usr/include/c++/4.8.2/deque" 3
|
|
|
|
# 59 "/usr/include/c++/4.8.2/deque" 3
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_deque.h" 1 3
|
|
# 66 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 88 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
inline size_t
|
|
__deque_buf_size(size_t __size)
|
|
{ return (__size < 512
|
|
? size_t(512 / __size) : size_t(1)); }
|
|
# 105 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
struct _Deque_iterator
|
|
{
|
|
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
|
|
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
|
|
|
|
static size_t _S_buffer_size()
|
|
{ return __deque_buf_size(sizeof(_Tp)); }
|
|
|
|
typedef std::random_access_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef _Ptr pointer;
|
|
typedef _Ref reference;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Tp** _Map_pointer;
|
|
typedef _Deque_iterator _Self;
|
|
|
|
_Tp* _M_cur;
|
|
_Tp* _M_first;
|
|
_Tp* _M_last;
|
|
_Map_pointer _M_node;
|
|
|
|
_Deque_iterator(_Tp* __x, _Map_pointer __y)
|
|
: _M_cur(__x), _M_first(*__y),
|
|
_M_last(*__y + _S_buffer_size()), _M_node(__y) { }
|
|
|
|
_Deque_iterator()
|
|
: _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
|
|
|
|
_Deque_iterator(const iterator& __x)
|
|
: _M_cur(__x._M_cur), _M_first(__x._M_first),
|
|
_M_last(__x._M_last), _M_node(__x._M_node) { }
|
|
|
|
reference
|
|
operator*() const
|
|
{ return *_M_cur; }
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return _M_cur; }
|
|
|
|
_Self&
|
|
operator++()
|
|
{
|
|
++_M_cur;
|
|
if (_M_cur == _M_last)
|
|
{
|
|
_M_set_node(_M_node + 1);
|
|
_M_cur = _M_first;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator++(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
++*this;
|
|
return __tmp;
|
|
}
|
|
|
|
_Self&
|
|
operator--()
|
|
{
|
|
if (_M_cur == _M_first)
|
|
{
|
|
_M_set_node(_M_node - 1);
|
|
_M_cur = _M_last;
|
|
}
|
|
--_M_cur;
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator--(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
--*this;
|
|
return __tmp;
|
|
}
|
|
|
|
_Self&
|
|
operator+=(difference_type __n)
|
|
{
|
|
const difference_type __offset = __n + (_M_cur - _M_first);
|
|
if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
|
|
_M_cur += __n;
|
|
else
|
|
{
|
|
const difference_type __node_offset =
|
|
__offset > 0 ? __offset / difference_type(_S_buffer_size())
|
|
: -difference_type((-__offset - 1)
|
|
/ _S_buffer_size()) - 1;
|
|
_M_set_node(_M_node + __node_offset);
|
|
_M_cur = _M_first + (__offset - __node_offset
|
|
* difference_type(_S_buffer_size()));
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator+(difference_type __n) const
|
|
{
|
|
_Self __tmp = *this;
|
|
return __tmp += __n;
|
|
}
|
|
|
|
_Self&
|
|
operator-=(difference_type __n)
|
|
{ return *this += -__n; }
|
|
|
|
_Self
|
|
operator-(difference_type __n) const
|
|
{
|
|
_Self __tmp = *this;
|
|
return __tmp -= __n;
|
|
}
|
|
|
|
reference
|
|
operator[](difference_type __n) const
|
|
{ return *(*this + __n); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_set_node(_Map_pointer __new_node)
|
|
{
|
|
_M_node = __new_node;
|
|
_M_first = *__new_node;
|
|
_M_last = _M_first + difference_type(_S_buffer_size());
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline bool
|
|
operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{ return __x._M_cur == __y._M_cur; }
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline bool
|
|
operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{ return __x._M_cur == __y._M_cur; }
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline bool
|
|
operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline bool
|
|
operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline bool
|
|
operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
|
|
: (__x._M_node < __y._M_node); }
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline bool
|
|
operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
|
|
: (__x._M_node < __y._M_node); }
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline bool
|
|
operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{ return __y < __x; }
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline bool
|
|
operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{ return __y < __x; }
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline bool
|
|
operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline bool
|
|
operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline bool
|
|
operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline bool
|
|
operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
|
|
operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
|
|
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
|
|
{
|
|
return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
|
|
(_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
|
|
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
|
|
+ (__y._M_last - __y._M_cur);
|
|
}
|
|
|
|
template<typename _Tp, typename _RefL, typename _PtrL,
|
|
typename _RefR, typename _PtrR>
|
|
inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
|
|
operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
|
|
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
|
|
{
|
|
return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
|
|
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
|
|
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
|
|
+ (__y._M_last - __y._M_cur);
|
|
}
|
|
|
|
template<typename _Tp, typename _Ref, typename _Ptr>
|
|
inline _Deque_iterator<_Tp, _Ref, _Ptr>
|
|
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
|
|
{ return __x + __n; }
|
|
|
|
template<typename _Tp>
|
|
void
|
|
fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
|
|
const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
|
|
|
|
template<typename _Tp>
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*>
|
|
copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
|
|
_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*>);
|
|
|
|
template<typename _Tp>
|
|
inline _Deque_iterator<_Tp, _Tp&, _Tp*>
|
|
copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*> __last,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
|
|
{ return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
|
|
_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
|
|
__result); }
|
|
|
|
template<typename _Tp>
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*>
|
|
copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
|
|
_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*>);
|
|
|
|
template<typename _Tp>
|
|
inline _Deque_iterator<_Tp, _Tp&, _Tp*>
|
|
copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*> __last,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
|
|
{ return std::copy_backward(_Deque_iterator<_Tp,
|
|
const _Tp&, const _Tp*>(__first),
|
|
_Deque_iterator<_Tp,
|
|
const _Tp&, const _Tp*>(__last),
|
|
__result); }
|
|
# 438 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
class _Deque_base
|
|
{
|
|
public:
|
|
typedef _Alloc allocator_type;
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_get_Tp_allocator()); }
|
|
|
|
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
|
|
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
|
|
|
|
_Deque_base()
|
|
: _M_impl()
|
|
{ _M_initialize_map(0); }
|
|
|
|
_Deque_base(size_t __num_elements)
|
|
: _M_impl()
|
|
{ _M_initialize_map(__num_elements); }
|
|
|
|
_Deque_base(const allocator_type& __a, size_t __num_elements)
|
|
: _M_impl(__a)
|
|
{ _M_initialize_map(__num_elements); }
|
|
|
|
_Deque_base(const allocator_type& __a)
|
|
: _M_impl(__a)
|
|
{ }
|
|
# 482 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
~_Deque_base();
|
|
|
|
protected:
|
|
|
|
|
|
|
|
typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
|
|
|
|
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
|
|
|
|
struct _Deque_impl
|
|
: public _Tp_alloc_type
|
|
{
|
|
_Tp** _M_map;
|
|
size_t _M_map_size;
|
|
iterator _M_start;
|
|
iterator _M_finish;
|
|
|
|
_Deque_impl()
|
|
: _Tp_alloc_type(), _M_map(0), _M_map_size(0),
|
|
_M_start(), _M_finish()
|
|
{ }
|
|
|
|
_Deque_impl(const _Tp_alloc_type& __a)
|
|
: _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
|
|
_M_start(), _M_finish()
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
_Tp_alloc_type&
|
|
_M_get_Tp_allocator()
|
|
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
|
|
|
|
const _Tp_alloc_type&
|
|
_M_get_Tp_allocator() const
|
|
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
|
|
|
|
_Map_alloc_type
|
|
_M_get_map_allocator() const
|
|
{ return _Map_alloc_type(_M_get_Tp_allocator()); }
|
|
|
|
_Tp*
|
|
_M_allocate_node()
|
|
{
|
|
return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
|
|
}
|
|
|
|
void
|
|
_M_deallocate_node(_Tp* __p)
|
|
{
|
|
_M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
|
|
}
|
|
|
|
_Tp**
|
|
_M_allocate_map(size_t __n)
|
|
{ return _M_get_map_allocator().allocate(__n); }
|
|
|
|
void
|
|
_M_deallocate_map(_Tp** __p, size_t __n)
|
|
{ _M_get_map_allocator().deallocate(__p, __n); }
|
|
|
|
protected:
|
|
void _M_initialize_map(size_t);
|
|
void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
|
|
void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
|
|
enum { _S_initial_map_size = 8 };
|
|
|
|
_Deque_impl _M_impl;
|
|
};
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
_Deque_base<_Tp, _Alloc>::
|
|
~_Deque_base()
|
|
{
|
|
if (this->_M_impl._M_map)
|
|
{
|
|
_M_destroy_nodes(this->_M_impl._M_start._M_node,
|
|
this->_M_impl._M_finish._M_node + 1);
|
|
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
|
|
}
|
|
}
|
|
# 579 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
_Deque_base<_Tp, _Alloc>::
|
|
_M_initialize_map(size_t __num_elements)
|
|
{
|
|
const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
|
|
+ 1);
|
|
|
|
this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
|
|
size_t(__num_nodes + 2));
|
|
this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
_Tp** __nstart = (this->_M_impl._M_map
|
|
+ (this->_M_impl._M_map_size - __num_nodes) / 2);
|
|
_Tp** __nfinish = __nstart + __num_nodes;
|
|
|
|
try
|
|
{ _M_create_nodes(__nstart, __nfinish); }
|
|
catch(...)
|
|
{
|
|
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
|
|
this->_M_impl._M_map = 0;
|
|
this->_M_impl._M_map_size = 0;
|
|
throw;
|
|
}
|
|
|
|
this->_M_impl._M_start._M_set_node(__nstart);
|
|
this->_M_impl._M_finish._M_set_node(__nfinish - 1);
|
|
this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
|
|
this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
|
|
+ __num_elements
|
|
% __deque_buf_size(sizeof(_Tp)));
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
_Deque_base<_Tp, _Alloc>::
|
|
_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
|
|
{
|
|
_Tp** __cur;
|
|
try
|
|
{
|
|
for (__cur = __nstart; __cur < __nfinish; ++__cur)
|
|
*__cur = this->_M_allocate_node();
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__nstart, __cur);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
_Deque_base<_Tp, _Alloc>::
|
|
_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
|
|
{
|
|
for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
|
|
_M_deallocate_node(*__n);
|
|
}
|
|
# 729 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
|
|
class deque : protected _Deque_base<_Tp, _Alloc>
|
|
{
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
typedef _Deque_base<_Tp, _Alloc> _Base;
|
|
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
|
|
|
|
public:
|
|
typedef _Tp value_type;
|
|
typedef typename _Tp_alloc_type::pointer pointer;
|
|
typedef typename _Tp_alloc_type::const_pointer const_pointer;
|
|
typedef typename _Tp_alloc_type::reference reference;
|
|
typedef typename _Tp_alloc_type::const_reference const_reference;
|
|
typedef typename _Base::iterator iterator;
|
|
typedef typename _Base::const_iterator const_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Alloc allocator_type;
|
|
|
|
protected:
|
|
typedef pointer* _Map_pointer;
|
|
|
|
static size_t _S_buffer_size()
|
|
{ return __deque_buf_size(sizeof(_Tp)); }
|
|
|
|
|
|
using _Base::_M_initialize_map;
|
|
using _Base::_M_create_nodes;
|
|
using _Base::_M_destroy_nodes;
|
|
using _Base::_M_allocate_node;
|
|
using _Base::_M_deallocate_node;
|
|
using _Base::_M_allocate_map;
|
|
using _Base::_M_deallocate_map;
|
|
using _Base::_M_get_Tp_allocator;
|
|
|
|
|
|
|
|
|
|
|
|
using _Base::_M_impl;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
deque()
|
|
: _Base() { }
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
deque(const allocator_type& __a)
|
|
: _Base(__a, 0) { }
|
|
# 827 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
explicit
|
|
deque(size_type __n, const value_type& __value = value_type(),
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(__a, __n)
|
|
{ _M_fill_initialize(__value); }
|
|
# 841 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
deque(const deque& __x)
|
|
: _Base(__x._M_get_Tp_allocator(), __x.size())
|
|
{ std::__uninitialized_copy_a(__x.begin(), __x.end(),
|
|
this->_M_impl._M_start,
|
|
_M_get_Tp_allocator()); }
|
|
# 901 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _InputIterator>
|
|
deque(_InputIterator __first, _InputIterator __last,
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(__a)
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_initialize_dispatch(__first, __last, _Integral());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
~deque()
|
|
{ _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
|
|
# 927 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
deque&
|
|
operator=(const deque& __x);
|
|
# 977 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
assign(size_type __n, const value_type& __val)
|
|
{ _M_fill_assign(__n, __val); }
|
|
# 1000 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
assign(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_assign_dispatch(__first, __last, _Integral());
|
|
}
|
|
# 1027 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return _Base::get_allocator(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin()
|
|
{ return this->_M_impl._M_start; }
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return this->_M_impl._M_start; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end()
|
|
{ return this->_M_impl._M_finish; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return this->_M_impl._M_finish; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return reverse_iterator(this->_M_impl._M_finish); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return const_reverse_iterator(this->_M_impl._M_finish); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return reverse_iterator(this->_M_impl._M_start); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return const_reverse_iterator(this->_M_impl._M_start); }
|
|
# 1141 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
size_type
|
|
size() const
|
|
{ return this->_M_impl._M_finish - this->_M_impl._M_start; }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_get_Tp_allocator().max_size(); }
|
|
# 1204 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
resize(size_type __new_size, value_type __x = value_type())
|
|
{
|
|
const size_type __len = size();
|
|
if (__new_size > __len)
|
|
insert(this->_M_impl._M_finish, __new_size - __len, __x);
|
|
else if (__new_size < __len)
|
|
_M_erase_at_end(this->_M_impl._M_start
|
|
+ difference_type(__new_size));
|
|
}
|
|
# 1227 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
bool
|
|
empty() const
|
|
{ return this->_M_impl._M_finish == this->_M_impl._M_start; }
|
|
# 1243 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
reference
|
|
operator[](size_type __n)
|
|
{ return this->_M_impl._M_start[difference_type(__n)]; }
|
|
# 1258 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
const_reference
|
|
operator[](size_type __n) const
|
|
{ return this->_M_impl._M_start[difference_type(__n)]; }
|
|
|
|
protected:
|
|
|
|
void
|
|
_M_range_check(size_type __n) const
|
|
{
|
|
if (__n >= this->size())
|
|
__throw_out_of_range(("deque::_M_range_check"));
|
|
}
|
|
|
|
public:
|
|
# 1283 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
reference
|
|
at(size_type __n)
|
|
{
|
|
_M_range_check(__n);
|
|
return (*this)[__n];
|
|
}
|
|
# 1301 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
const_reference
|
|
at(size_type __n) const
|
|
{
|
|
_M_range_check(__n);
|
|
return (*this)[__n];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
front()
|
|
{ return *begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
front() const
|
|
{ return *begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
back()
|
|
{
|
|
iterator __tmp = end();
|
|
--__tmp;
|
|
return *__tmp;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
back() const
|
|
{
|
|
const_iterator __tmp = end();
|
|
--__tmp;
|
|
return *__tmp;
|
|
}
|
|
# 1358 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
push_front(const value_type& __x)
|
|
{
|
|
if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
|
|
{
|
|
this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
|
|
--this->_M_impl._M_start._M_cur;
|
|
}
|
|
else
|
|
_M_push_front_aux(__x);
|
|
}
|
|
# 1389 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
push_back(const value_type& __x)
|
|
{
|
|
if (this->_M_impl._M_finish._M_cur
|
|
!= this->_M_impl._M_finish._M_last - 1)
|
|
{
|
|
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
|
|
++this->_M_impl._M_finish._M_cur;
|
|
}
|
|
else
|
|
_M_push_back_aux(__x);
|
|
}
|
|
# 1420 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
pop_front()
|
|
{
|
|
if (this->_M_impl._M_start._M_cur
|
|
!= this->_M_impl._M_start._M_last - 1)
|
|
{
|
|
this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
|
|
++this->_M_impl._M_start._M_cur;
|
|
}
|
|
else
|
|
_M_pop_front_aux();
|
|
}
|
|
# 1441 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
pop_back()
|
|
{
|
|
if (this->_M_impl._M_finish._M_cur
|
|
!= this->_M_impl._M_finish._M_first)
|
|
{
|
|
--this->_M_impl._M_finish._M_cur;
|
|
this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
|
|
}
|
|
else
|
|
_M_pop_back_aux();
|
|
}
|
|
# 1478 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
iterator
|
|
insert(iterator __position, const value_type& __x);
|
|
# 1518 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
insert(iterator __position, size_type __n, const value_type& __x)
|
|
{ _M_fill_insert(__position, __n, __x); }
|
|
# 1540 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(iterator __position, _InputIterator __first,
|
|
_InputIterator __last)
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_insert_dispatch(__position, __first, __last, _Integral());
|
|
}
|
|
# 1564 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
iterator
|
|
erase(iterator __position);
|
|
# 1583 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
iterator
|
|
erase(iterator __first, iterator __last);
|
|
# 1595 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
swap(deque& __x)
|
|
{
|
|
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
|
|
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
|
|
std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
|
|
std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
|
|
|
|
|
|
|
|
std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
|
|
__x._M_get_Tp_allocator());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
clear()
|
|
{ _M_erase_at_end(begin()); }
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Integer>
|
|
void
|
|
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
|
|
{
|
|
_M_initialize_map(static_cast<size_type>(__n));
|
|
_M_fill_initialize(__x);
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{
|
|
typedef typename std::iterator_traits<_InputIterator>::
|
|
iterator_category _IterCategory;
|
|
_M_range_initialize(__first, __last, _IterCategory());
|
|
}
|
|
# 1657 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_range_initialize(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag);
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag);
|
|
# 1679 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
_M_fill_initialize(const value_type& __value);
|
|
# 1695 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
|
|
{ _M_fill_assign(__n, __val); }
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{
|
|
typedef typename std::iterator_traits<_InputIterator>::
|
|
iterator_category _IterCategory;
|
|
_M_assign_aux(__first, __last, _IterCategory());
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_assign_aux(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag);
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag)
|
|
{
|
|
const size_type __len = std::distance(__first, __last);
|
|
if (__len > size())
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, size());
|
|
std::copy(__first, __mid, begin());
|
|
insert(end(), __mid, __last);
|
|
}
|
|
else
|
|
_M_erase_at_end(std::copy(__first, __last, begin()));
|
|
}
|
|
|
|
|
|
|
|
void
|
|
_M_fill_assign(size_type __n, const value_type& __val)
|
|
{
|
|
if (__n > size())
|
|
{
|
|
std::fill(begin(), end(), __val);
|
|
insert(end(), __n - size(), __val);
|
|
}
|
|
else
|
|
{
|
|
_M_erase_at_end(begin() + difference_type(__n));
|
|
std::fill(begin(), end(), __val);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void _M_push_back_aux(const value_type&);
|
|
|
|
void _M_push_front_aux(const value_type&);
|
|
# 1766 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void _M_pop_back_aux();
|
|
|
|
void _M_pop_front_aux();
|
|
# 1778 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_insert_dispatch(iterator __pos,
|
|
_Integer __n, _Integer __x, __true_type)
|
|
{ _M_fill_insert(__pos, __n, __x); }
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_insert_dispatch(iterator __pos,
|
|
_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{
|
|
typedef typename std::iterator_traits<_InputIterator>::
|
|
iterator_category _IterCategory;
|
|
_M_range_insert_aux(__pos, __first, __last, _IterCategory());
|
|
}
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_range_insert_aux(iterator __pos, _InputIterator __first,
|
|
_InputIterator __last, std::input_iterator_tag);
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_range_insert_aux(iterator __pos, _ForwardIterator __first,
|
|
_ForwardIterator __last, std::forward_iterator_tag);
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
|
|
|
|
|
|
|
|
iterator
|
|
_M_insert_aux(iterator __pos, const value_type& __x);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
|
|
|
|
|
|
template<typename _ForwardIterator>
|
|
void
|
|
_M_insert_aux(iterator __pos,
|
|
_ForwardIterator __first, _ForwardIterator __last,
|
|
size_type __n);
|
|
|
|
|
|
|
|
|
|
void
|
|
_M_destroy_data_aux(iterator __first, iterator __last);
|
|
|
|
|
|
|
|
template<typename _Alloc1>
|
|
void
|
|
_M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
|
|
{ _M_destroy_data_aux(__first, __last); }
|
|
|
|
void
|
|
_M_destroy_data(iterator __first, iterator __last,
|
|
const std::allocator<_Tp>&)
|
|
{
|
|
if (!__has_trivial_destructor(value_type))
|
|
_M_destroy_data_aux(__first, __last);
|
|
}
|
|
|
|
|
|
void
|
|
_M_erase_at_begin(iterator __pos)
|
|
{
|
|
_M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
|
|
_M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
|
|
this->_M_impl._M_start = __pos;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
_M_erase_at_end(iterator __pos)
|
|
{
|
|
_M_destroy_data(__pos, end(), _M_get_Tp_allocator());
|
|
_M_destroy_nodes(__pos._M_node + 1,
|
|
this->_M_impl._M_finish._M_node + 1);
|
|
this->_M_impl._M_finish = __pos;
|
|
}
|
|
# 1887 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
iterator
|
|
_M_reserve_elements_at_front(size_type __n)
|
|
{
|
|
const size_type __vacancies = this->_M_impl._M_start._M_cur
|
|
- this->_M_impl._M_start._M_first;
|
|
if (__n > __vacancies)
|
|
_M_new_elements_at_front(__n - __vacancies);
|
|
return this->_M_impl._M_start - difference_type(__n);
|
|
}
|
|
|
|
iterator
|
|
_M_reserve_elements_at_back(size_type __n)
|
|
{
|
|
const size_type __vacancies = (this->_M_impl._M_finish._M_last
|
|
- this->_M_impl._M_finish._M_cur) - 1;
|
|
if (__n > __vacancies)
|
|
_M_new_elements_at_back(__n - __vacancies);
|
|
return this->_M_impl._M_finish + difference_type(__n);
|
|
}
|
|
|
|
void
|
|
_M_new_elements_at_front(size_type __new_elements);
|
|
|
|
void
|
|
_M_new_elements_at_back(size_type __new_elements);
|
|
# 1923 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
void
|
|
_M_reserve_map_at_back(size_type __nodes_to_add = 1)
|
|
{
|
|
if (__nodes_to_add + 1 > this->_M_impl._M_map_size
|
|
- (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
|
|
_M_reallocate_map(__nodes_to_add, false);
|
|
}
|
|
|
|
void
|
|
_M_reserve_map_at_front(size_type __nodes_to_add = 1)
|
|
{
|
|
if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
|
|
- this->_M_impl._M_map))
|
|
_M_reallocate_map(__nodes_to_add, true);
|
|
}
|
|
|
|
void
|
|
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
|
|
|
|
};
|
|
# 1955 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator==(const deque<_Tp, _Alloc>& __x,
|
|
const deque<_Tp, _Alloc>& __y)
|
|
{ return __x.size() == __y.size()
|
|
&& std::equal(__x.begin(), __x.end(), __y.begin()); }
|
|
# 1973 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator<(const deque<_Tp, _Alloc>& __x,
|
|
const deque<_Tp, _Alloc>& __y)
|
|
{ return std::lexicographical_compare(__x.begin(), __x.end(),
|
|
__y.begin(), __y.end()); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator!=(const deque<_Tp, _Alloc>& __x,
|
|
const deque<_Tp, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator>(const deque<_Tp, _Alloc>& __x,
|
|
const deque<_Tp, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator<=(const deque<_Tp, _Alloc>& __x,
|
|
const deque<_Tp, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator>=(const deque<_Tp, _Alloc>& __x,
|
|
const deque<_Tp, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline void
|
|
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
|
|
|
|
}
|
|
# 65 "/usr/include/c++/4.8.2/deque" 2 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/deque.tcc" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 90 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
template <typename _Tp, typename _Alloc>
|
|
deque<_Tp, _Alloc>&
|
|
deque<_Tp, _Alloc>::
|
|
operator=(const deque& __x)
|
|
{
|
|
const size_type __len = size();
|
|
if (&__x != this)
|
|
{
|
|
if (__len >= __x.size())
|
|
_M_erase_at_end(std::copy(__x.begin(), __x.end(),
|
|
this->_M_impl._M_start));
|
|
else
|
|
{
|
|
const_iterator __mid = __x.begin() + difference_type(__len);
|
|
std::copy(__x.begin(), __mid, this->_M_impl._M_start);
|
|
insert(this->_M_impl._M_finish, __mid, __x.end());
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
# 146 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
template <typename _Tp, typename _Alloc>
|
|
typename deque<_Tp, _Alloc>::iterator
|
|
deque<_Tp, _Alloc>::
|
|
insert(iterator __position, const value_type& __x)
|
|
{
|
|
if (__position._M_cur == this->_M_impl._M_start._M_cur)
|
|
{
|
|
push_front(__x);
|
|
return this->_M_impl._M_start;
|
|
}
|
|
else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
|
|
{
|
|
push_back(__x);
|
|
iterator __tmp = this->_M_impl._M_finish;
|
|
--__tmp;
|
|
return __tmp;
|
|
}
|
|
else
|
|
return _M_insert_aux(__position, __x);
|
|
}
|
|
# 191 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
template <typename _Tp, typename _Alloc>
|
|
typename deque<_Tp, _Alloc>::iterator
|
|
deque<_Tp, _Alloc>::
|
|
erase(iterator __position)
|
|
{
|
|
iterator __next = __position;
|
|
++__next;
|
|
const difference_type __index = __position - begin();
|
|
if (static_cast<size_type>(__index) < (size() >> 1))
|
|
{
|
|
if (__position != begin())
|
|
std::copy_backward(begin(), __position, __next);
|
|
pop_front();
|
|
}
|
|
else
|
|
{
|
|
if (__next != end())
|
|
std::copy(__next, end(), __position);
|
|
pop_back();
|
|
}
|
|
return begin() + __index;
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
typename deque<_Tp, _Alloc>::iterator
|
|
deque<_Tp, _Alloc>::
|
|
erase(iterator __first, iterator __last)
|
|
{
|
|
if (__first == __last)
|
|
return __first;
|
|
else if (__first == begin() && __last == end())
|
|
{
|
|
clear();
|
|
return end();
|
|
}
|
|
else
|
|
{
|
|
const difference_type __n = __last - __first;
|
|
const difference_type __elems_before = __first - begin();
|
|
if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
|
|
{
|
|
if (__first != begin())
|
|
std::copy_backward(begin(), __first, __last);
|
|
_M_erase_at_begin(begin() + __n);
|
|
}
|
|
else
|
|
{
|
|
if (__last != end())
|
|
std::copy(__last, end(), __first);
|
|
_M_erase_at_end(end() - __n);
|
|
}
|
|
return begin() + __elems_before;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, class _Alloc>
|
|
template <typename _InputIterator>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_assign_aux(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag)
|
|
{
|
|
iterator __cur = begin();
|
|
for (; __first != __last && __cur != end(); ++__cur, ++__first)
|
|
*__cur = *__first;
|
|
if (__first == __last)
|
|
_M_erase_at_end(__cur);
|
|
else
|
|
insert(end(), __first, __last);
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
|
|
{
|
|
if (__pos._M_cur == this->_M_impl._M_start._M_cur)
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
try
|
|
{
|
|
std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
|
|
__x, _M_get_Tp_allocator());
|
|
this->_M_impl._M_start = __new_start;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node,
|
|
this->_M_impl._M_start._M_node);
|
|
throw;
|
|
}
|
|
}
|
|
else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
try
|
|
{
|
|
std::__uninitialized_fill_a(this->_M_impl._M_finish,
|
|
__new_finish, __x,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __new_finish;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
_M_insert_aux(__pos, __n, __x);
|
|
}
|
|
# 348 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_fill_initialize(const value_type& __value)
|
|
{
|
|
_Map_pointer __cur;
|
|
try
|
|
{
|
|
for (__cur = this->_M_impl._M_start._M_node;
|
|
__cur < this->_M_impl._M_finish._M_node;
|
|
++__cur)
|
|
std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
|
|
__value, _M_get_Tp_allocator());
|
|
std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
|
|
this->_M_impl._M_finish._M_cur,
|
|
__value, _M_get_Tp_allocator());
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
|
|
_M_get_Tp_allocator());
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _InputIterator>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_range_initialize(_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag)
|
|
{
|
|
this->_M_initialize_map(0);
|
|
try
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
|
|
|
|
|
|
push_back(*__first);
|
|
|
|
}
|
|
catch(...)
|
|
{
|
|
clear();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _ForwardIterator>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag)
|
|
{
|
|
const size_type __n = std::distance(__first, __last);
|
|
this->_M_initialize_map(__n);
|
|
|
|
_Map_pointer __cur_node;
|
|
try
|
|
{
|
|
for (__cur_node = this->_M_impl._M_start._M_node;
|
|
__cur_node < this->_M_impl._M_finish._M_node;
|
|
++__cur_node)
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, _S_buffer_size());
|
|
std::__uninitialized_copy_a(__first, __mid, *__cur_node,
|
|
_M_get_Tp_allocator());
|
|
__first = __mid;
|
|
}
|
|
std::__uninitialized_copy_a(__first, __last,
|
|
this->_M_impl._M_finish._M_first,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
catch(...)
|
|
{
|
|
std::_Destroy(this->_M_impl._M_start,
|
|
iterator(*__cur_node, __cur_node),
|
|
_M_get_Tp_allocator());
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_push_back_aux(const value_type& __t)
|
|
|
|
{
|
|
_M_reserve_map_at_back();
|
|
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
|
|
try
|
|
{
|
|
|
|
|
|
|
|
|
|
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
|
|
|
|
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
|
|
+ 1);
|
|
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_push_front_aux(const value_type& __t)
|
|
|
|
{
|
|
_M_reserve_map_at_front();
|
|
*(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
|
|
try
|
|
{
|
|
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
|
|
- 1);
|
|
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
|
|
|
|
|
|
|
|
|
|
this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t);
|
|
|
|
}
|
|
catch(...)
|
|
{
|
|
++this->_M_impl._M_start;
|
|
_M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void deque<_Tp, _Alloc>::
|
|
_M_pop_back_aux()
|
|
{
|
|
_M_deallocate_node(this->_M_impl._M_finish._M_first);
|
|
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
|
|
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
|
|
this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void deque<_Tp, _Alloc>::
|
|
_M_pop_front_aux()
|
|
{
|
|
this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
|
|
_M_deallocate_node(this->_M_impl._M_start._M_first);
|
|
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
|
|
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _InputIterator>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_range_insert_aux(iterator __pos,
|
|
_InputIterator __first, _InputIterator __last,
|
|
std::input_iterator_tag)
|
|
{ std::copy(__first, __last, std::inserter(*this, __pos)); }
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _ForwardIterator>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_range_insert_aux(iterator __pos,
|
|
_ForwardIterator __first, _ForwardIterator __last,
|
|
std::forward_iterator_tag)
|
|
{
|
|
const size_type __n = std::distance(__first, __last);
|
|
if (__pos._M_cur == this->_M_impl._M_start._M_cur)
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
try
|
|
{
|
|
std::__uninitialized_copy_a(__first, __last, __new_start,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_start = __new_start;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node,
|
|
this->_M_impl._M_start._M_node);
|
|
throw;
|
|
}
|
|
}
|
|
else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
try
|
|
{
|
|
std::__uninitialized_copy_a(__first, __last,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __new_finish;
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
_M_insert_aux(__pos, __first, __last, __n);
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
# 592 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
typename deque<_Tp, _Alloc>::iterator
|
|
deque<_Tp, _Alloc>::
|
|
_M_insert_aux(iterator __pos, const value_type& __x)
|
|
{
|
|
value_type __x_copy = __x;
|
|
|
|
difference_type __index = __pos - this->_M_impl._M_start;
|
|
if (static_cast<size_type>(__index) < size() / 2)
|
|
{
|
|
push_front((front()));
|
|
iterator __front1 = this->_M_impl._M_start;
|
|
++__front1;
|
|
iterator __front2 = __front1;
|
|
++__front2;
|
|
__pos = this->_M_impl._M_start + __index;
|
|
iterator __pos1 = __pos;
|
|
++__pos1;
|
|
std::copy(__front2, __pos1, __front1);
|
|
}
|
|
else
|
|
{
|
|
push_back((back()));
|
|
iterator __back1 = this->_M_impl._M_finish;
|
|
--__back1;
|
|
iterator __back2 = __back1;
|
|
--__back2;
|
|
__pos = this->_M_impl._M_start + __index;
|
|
std::copy_backward(__pos, __back2, __back1);
|
|
}
|
|
*__pos = (__x_copy);
|
|
return __pos;
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
|
|
{
|
|
const difference_type __elems_before = __pos - this->_M_impl._M_start;
|
|
const size_type __length = this->size();
|
|
value_type __x_copy = __x;
|
|
if (__elems_before < difference_type(__length / 2))
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
iterator __old_start = this->_M_impl._M_start;
|
|
__pos = this->_M_impl._M_start + __elems_before;
|
|
try
|
|
{
|
|
if (__elems_before >= difference_type(__n))
|
|
{
|
|
iterator __start_n = (this->_M_impl._M_start
|
|
+ difference_type(__n));
|
|
std::__uninitialized_move_a(this->_M_impl._M_start,
|
|
__start_n, __new_start,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_start = __new_start;
|
|
std::copy(__start_n, __pos, __old_start);
|
|
std::fill(__pos - difference_type(__n), __pos, __x_copy);
|
|
}
|
|
else
|
|
{
|
|
std::__uninitialized_move_fill(this->_M_impl._M_start,
|
|
__pos, __new_start,
|
|
this->_M_impl._M_start,
|
|
__x_copy,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_start = __new_start;
|
|
std::fill(__old_start, __pos, __x_copy);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node,
|
|
this->_M_impl._M_start._M_node);
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
iterator __old_finish = this->_M_impl._M_finish;
|
|
const difference_type __elems_after =
|
|
difference_type(__length) - __elems_before;
|
|
__pos = this->_M_impl._M_finish - __elems_after;
|
|
try
|
|
{
|
|
if (__elems_after > difference_type(__n))
|
|
{
|
|
iterator __finish_n = (this->_M_impl._M_finish
|
|
- difference_type(__n));
|
|
std::__uninitialized_move_a(__finish_n,
|
|
this->_M_impl._M_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __new_finish;
|
|
std::copy_backward(__pos, __finish_n, __old_finish);
|
|
std::fill(__pos, __pos + difference_type(__n), __x_copy);
|
|
}
|
|
else
|
|
{
|
|
std::__uninitialized_fill_move(this->_M_impl._M_finish,
|
|
__pos + difference_type(__n),
|
|
__x_copy, __pos,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __new_finish;
|
|
std::fill(__pos, __old_finish, __x_copy);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
template <typename _ForwardIterator>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_insert_aux(iterator __pos,
|
|
_ForwardIterator __first, _ForwardIterator __last,
|
|
size_type __n)
|
|
{
|
|
const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
|
|
const size_type __length = size();
|
|
if (static_cast<size_type>(__elemsbefore) < __length / 2)
|
|
{
|
|
iterator __new_start = _M_reserve_elements_at_front(__n);
|
|
iterator __old_start = this->_M_impl._M_start;
|
|
__pos = this->_M_impl._M_start + __elemsbefore;
|
|
try
|
|
{
|
|
if (__elemsbefore >= difference_type(__n))
|
|
{
|
|
iterator __start_n = (this->_M_impl._M_start
|
|
+ difference_type(__n));
|
|
std::__uninitialized_move_a(this->_M_impl._M_start,
|
|
__start_n, __new_start,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_start = __new_start;
|
|
std::copy(__start_n, __pos, __old_start);
|
|
std::copy(__first, __last, __pos - difference_type(__n));
|
|
}
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, difference_type(__n) - __elemsbefore);
|
|
std::__uninitialized_move_copy(this->_M_impl._M_start,
|
|
__pos, __first, __mid,
|
|
__new_start,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_start = __new_start;
|
|
std::copy(__mid, __last, __old_start);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(__new_start._M_node,
|
|
this->_M_impl._M_start._M_node);
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iterator __new_finish = _M_reserve_elements_at_back(__n);
|
|
iterator __old_finish = this->_M_impl._M_finish;
|
|
const difference_type __elemsafter =
|
|
difference_type(__length) - __elemsbefore;
|
|
__pos = this->_M_impl._M_finish - __elemsafter;
|
|
try
|
|
{
|
|
if (__elemsafter > difference_type(__n))
|
|
{
|
|
iterator __finish_n = (this->_M_impl._M_finish
|
|
- difference_type(__n));
|
|
std::__uninitialized_move_a(__finish_n,
|
|
this->_M_impl._M_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __new_finish;
|
|
std::copy_backward(__pos, __finish_n, __old_finish);
|
|
std::copy(__first, __last, __pos);
|
|
}
|
|
else
|
|
{
|
|
_ForwardIterator __mid = __first;
|
|
std::advance(__mid, __elemsafter);
|
|
std::__uninitialized_copy_move(__mid, __last, __pos,
|
|
this->_M_impl._M_finish,
|
|
this->_M_impl._M_finish,
|
|
_M_get_Tp_allocator());
|
|
this->_M_impl._M_finish = __new_finish;
|
|
std::copy(__first, __mid, __pos);
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
|
|
__new_finish._M_node + 1);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_destroy_data_aux(iterator __first, iterator __last)
|
|
{
|
|
for (_Map_pointer __node = __first._M_node + 1;
|
|
__node < __last._M_node; ++__node)
|
|
std::_Destroy(*__node, *__node + _S_buffer_size(),
|
|
_M_get_Tp_allocator());
|
|
|
|
if (__first._M_node != __last._M_node)
|
|
{
|
|
std::_Destroy(__first._M_cur, __first._M_last,
|
|
_M_get_Tp_allocator());
|
|
std::_Destroy(__last._M_first, __last._M_cur,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
else
|
|
std::_Destroy(__first._M_cur, __last._M_cur,
|
|
_M_get_Tp_allocator());
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_new_elements_at_front(size_type __new_elems)
|
|
{
|
|
if (this->max_size() - this->size() < __new_elems)
|
|
__throw_length_error(("deque::_M_new_elements_at_front"));
|
|
|
|
const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
|
|
/ _S_buffer_size());
|
|
_M_reserve_map_at_front(__new_nodes);
|
|
size_type __i;
|
|
try
|
|
{
|
|
for (__i = 1; __i <= __new_nodes; ++__i)
|
|
*(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
|
|
}
|
|
catch(...)
|
|
{
|
|
for (size_type __j = 1; __j < __i; ++__j)
|
|
_M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_new_elements_at_back(size_type __new_elems)
|
|
{
|
|
if (this->max_size() - this->size() < __new_elems)
|
|
__throw_length_error(("deque::_M_new_elements_at_back"));
|
|
|
|
const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
|
|
/ _S_buffer_size());
|
|
_M_reserve_map_at_back(__new_nodes);
|
|
size_type __i;
|
|
try
|
|
{
|
|
for (__i = 1; __i <= __new_nodes; ++__i)
|
|
*(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
|
|
}
|
|
catch(...)
|
|
{
|
|
for (size_type __j = 1; __j < __i; ++__j)
|
|
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
template <typename _Tp, typename _Alloc>
|
|
void
|
|
deque<_Tp, _Alloc>::
|
|
_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
|
|
{
|
|
const size_type __old_num_nodes
|
|
= this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
|
|
const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
|
|
|
|
_Map_pointer __new_nstart;
|
|
if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
|
|
{
|
|
__new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
|
|
- __new_num_nodes) / 2
|
|
+ (__add_at_front ? __nodes_to_add : 0);
|
|
if (__new_nstart < this->_M_impl._M_start._M_node)
|
|
std::copy(this->_M_impl._M_start._M_node,
|
|
this->_M_impl._M_finish._M_node + 1,
|
|
__new_nstart);
|
|
else
|
|
std::copy_backward(this->_M_impl._M_start._M_node,
|
|
this->_M_impl._M_finish._M_node + 1,
|
|
__new_nstart + __old_num_nodes);
|
|
}
|
|
else
|
|
{
|
|
size_type __new_map_size = this->_M_impl._M_map_size
|
|
+ std::max(this->_M_impl._M_map_size,
|
|
__nodes_to_add) + 2;
|
|
|
|
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
|
|
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
|
|
+ (__add_at_front ? __nodes_to_add : 0);
|
|
std::copy(this->_M_impl._M_start._M_node,
|
|
this->_M_impl._M_finish._M_node + 1,
|
|
__new_nstart);
|
|
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
|
|
|
|
this->_M_impl._M_map = __new_map;
|
|
this->_M_impl._M_map_size = __new_map_size;
|
|
}
|
|
|
|
this->_M_impl._M_start._M_set_node(__new_nstart);
|
|
this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
|
|
}
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
void
|
|
fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
|
|
const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
|
|
{
|
|
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
|
|
|
|
for (typename _Self::_Map_pointer __node = __first._M_node + 1;
|
|
__node < __last._M_node; ++__node)
|
|
std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
|
|
|
|
if (__first._M_node != __last._M_node)
|
|
{
|
|
std::fill(__first._M_cur, __first._M_last, __value);
|
|
std::fill(__last._M_first, __last._M_cur, __value);
|
|
}
|
|
else
|
|
std::fill(__first._M_cur, __last._M_cur, __value);
|
|
}
|
|
|
|
template<typename _Tp>
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*>
|
|
copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
|
|
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
|
|
{
|
|
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
|
|
typedef typename _Self::difference_type difference_type;
|
|
|
|
difference_type __len = __last - __first;
|
|
while (__len > 0)
|
|
{
|
|
const difference_type __clen
|
|
= std::min(__len, std::min(__first._M_last - __first._M_cur,
|
|
__result._M_last - __result._M_cur));
|
|
std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
|
|
__first += __clen;
|
|
__result += __clen;
|
|
__len -= __clen;
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*>
|
|
copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
|
|
_Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
|
|
_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
|
|
{
|
|
typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
|
|
typedef typename _Self::difference_type difference_type;
|
|
|
|
difference_type __len = __last - __first;
|
|
while (__len > 0)
|
|
{
|
|
difference_type __llen = __last._M_cur - __last._M_first;
|
|
_Tp* __lend = __last._M_cur;
|
|
|
|
difference_type __rlen = __result._M_cur - __result._M_first;
|
|
_Tp* __rend = __result._M_cur;
|
|
|
|
if (!__llen)
|
|
{
|
|
__llen = _Self::_S_buffer_size();
|
|
__lend = *(__last._M_node - 1) + __llen;
|
|
}
|
|
if (!__rlen)
|
|
{
|
|
__rlen = _Self::_S_buffer_size();
|
|
__rend = *(__result._M_node - 1) + __rlen;
|
|
}
|
|
|
|
const difference_type __clen = std::min(__len,
|
|
std::min(__llen, __rlen));
|
|
std::copy_backward(__lend - __clen, __lend, __rend);
|
|
__last -= __clen;
|
|
__result -= __clen;
|
|
__len -= __clen;
|
|
}
|
|
return __result;
|
|
}
|
|
# 1065 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
|
|
|
|
}
|
|
# 67 "/usr/include/c++/4.8.2/deque" 2 3
|
|
# 61 "/usr/include/c++/4.8.2/queue" 2 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_heap.h" 1 3
|
|
# 61 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance>
|
|
_Distance
|
|
__is_heap_until(_RandomAccessIterator __first, _Distance __n)
|
|
{
|
|
_Distance __parent = 0;
|
|
for (_Distance __child = 1; __child < __n; ++__child)
|
|
{
|
|
if (__first[__parent] < __first[__child])
|
|
return __child;
|
|
if ((__child & 1) == 0)
|
|
++__parent;
|
|
}
|
|
return __n;
|
|
}
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance,
|
|
typename _Compare>
|
|
_Distance
|
|
__is_heap_until(_RandomAccessIterator __first, _Distance __n,
|
|
_Compare __comp)
|
|
{
|
|
_Distance __parent = 0;
|
|
for (_Distance __child = 1; __child < __n; ++__child)
|
|
{
|
|
if (__comp(__first[__parent], __first[__child]))
|
|
return __child;
|
|
if ((__child & 1) == 0)
|
|
++__parent;
|
|
}
|
|
return __n;
|
|
}
|
|
|
|
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance>
|
|
inline bool
|
|
__is_heap(_RandomAccessIterator __first, _Distance __n)
|
|
{ return std::__is_heap_until(__first, __n) == __n; }
|
|
|
|
template<typename _RandomAccessIterator, typename _Compare,
|
|
typename _Distance>
|
|
inline bool
|
|
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
|
|
{ return std::__is_heap_until(__first, __n, __comp) == __n; }
|
|
|
|
template<typename _RandomAccessIterator>
|
|
inline bool
|
|
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
|
{ return std::__is_heap(__first, std::distance(__first, __last)); }
|
|
|
|
template<typename _RandomAccessIterator, typename _Compare>
|
|
inline bool
|
|
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
_Compare __comp)
|
|
{ return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
|
|
|
|
|
|
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
|
|
void
|
|
__push_heap(_RandomAccessIterator __first,
|
|
_Distance __holeIndex, _Distance __topIndex, _Tp __value)
|
|
{
|
|
_Distance __parent = (__holeIndex - 1) / 2;
|
|
while (__holeIndex > __topIndex && *(__first + __parent) < __value)
|
|
{
|
|
*(__first + __holeIndex) = (*(__first + __parent));
|
|
__holeIndex = __parent;
|
|
__parent = (__holeIndex - 1) / 2;
|
|
}
|
|
*(__first + __holeIndex) = (__value);
|
|
}
|
|
# 154 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator>
|
|
inline void
|
|
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
;
|
|
|
|
_ValueType __value = (*(__last - 1));
|
|
std::__push_heap(__first, _DistanceType((__last - __first) - 1),
|
|
_DistanceType(0), (__value));
|
|
}
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
|
|
typename _Compare>
|
|
void
|
|
__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
|
|
_Distance __topIndex, _Tp __value, _Compare __comp)
|
|
{
|
|
_Distance __parent = (__holeIndex - 1) / 2;
|
|
while (__holeIndex > __topIndex
|
|
&& __comp(*(__first + __parent), __value))
|
|
{
|
|
*(__first + __holeIndex) = (*(__first + __parent));
|
|
__holeIndex = __parent;
|
|
__parent = (__holeIndex - 1) / 2;
|
|
}
|
|
*(__first + __holeIndex) = (__value);
|
|
}
|
|
# 204 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator, typename _Compare>
|
|
inline void
|
|
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
_Compare __comp)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
|
|
|
|
|
|
;
|
|
;
|
|
|
|
_ValueType __value = (*(__last - 1));
|
|
std::__push_heap(__first, _DistanceType((__last - __first) - 1),
|
|
_DistanceType(0), (__value), __comp);
|
|
}
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
|
|
void
|
|
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
|
|
_Distance __len, _Tp __value)
|
|
{
|
|
const _Distance __topIndex = __holeIndex;
|
|
_Distance __secondChild = __holeIndex;
|
|
while (__secondChild < (__len - 1) / 2)
|
|
{
|
|
__secondChild = 2 * (__secondChild + 1);
|
|
if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
|
|
__secondChild--;
|
|
*(__first + __holeIndex) = (*(__first + __secondChild));
|
|
__holeIndex = __secondChild;
|
|
}
|
|
if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
|
|
{
|
|
__secondChild = 2 * (__secondChild + 1);
|
|
*(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
|
|
;
|
|
__holeIndex = __secondChild - 1;
|
|
}
|
|
std::__push_heap(__first, __holeIndex, __topIndex,
|
|
(__value));
|
|
}
|
|
|
|
template<typename _RandomAccessIterator>
|
|
inline void
|
|
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
_RandomAccessIterator __result)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
_ValueType __value = (*__result);
|
|
*__result = (*__first);
|
|
std::__adjust_heap(__first, _DistanceType(0),
|
|
_DistanceType(__last - __first),
|
|
(__value));
|
|
}
|
|
# 279 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator>
|
|
inline void
|
|
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
;
|
|
;
|
|
|
|
if (__last - __first > 1)
|
|
{
|
|
--__last;
|
|
std::__pop_heap(__first, __last, __last);
|
|
}
|
|
}
|
|
|
|
template<typename _RandomAccessIterator, typename _Distance,
|
|
typename _Tp, typename _Compare>
|
|
void
|
|
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
|
|
_Distance __len, _Tp __value, _Compare __comp)
|
|
{
|
|
const _Distance __topIndex = __holeIndex;
|
|
_Distance __secondChild = __holeIndex;
|
|
while (__secondChild < (__len - 1) / 2)
|
|
{
|
|
__secondChild = 2 * (__secondChild + 1);
|
|
if (__comp(*(__first + __secondChild),
|
|
*(__first + (__secondChild - 1))))
|
|
__secondChild--;
|
|
*(__first + __holeIndex) = (*(__first + __secondChild));
|
|
__holeIndex = __secondChild;
|
|
}
|
|
if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
|
|
{
|
|
__secondChild = 2 * (__secondChild + 1);
|
|
*(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
|
|
;
|
|
__holeIndex = __secondChild - 1;
|
|
}
|
|
std::__push_heap(__first, __holeIndex, __topIndex,
|
|
(__value), __comp);
|
|
}
|
|
|
|
template<typename _RandomAccessIterator, typename _Compare>
|
|
inline void
|
|
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
_RandomAccessIterator __result, _Compare __comp)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
_ValueType __value = (*__result);
|
|
*__result = (*__first);
|
|
std::__adjust_heap(__first, _DistanceType(0),
|
|
_DistanceType(__last - __first),
|
|
(__value), __comp);
|
|
}
|
|
# 357 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator, typename _Compare>
|
|
inline void
|
|
pop_heap(_RandomAccessIterator __first,
|
|
_RandomAccessIterator __last, _Compare __comp)
|
|
{
|
|
|
|
|
|
|
|
;
|
|
;
|
|
;
|
|
|
|
if (__last - __first > 1)
|
|
{
|
|
--__last;
|
|
std::__pop_heap(__first, __last, __last, __comp);
|
|
}
|
|
}
|
|
# 384 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator>
|
|
void
|
|
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
if (__last - __first < 2)
|
|
return;
|
|
|
|
const _DistanceType __len = __last - __first;
|
|
_DistanceType __parent = (__len - 2) / 2;
|
|
while (true)
|
|
{
|
|
_ValueType __value = (*(__first + __parent));
|
|
std::__adjust_heap(__first, __parent, __len, (__value));
|
|
if (__parent == 0)
|
|
return;
|
|
__parent--;
|
|
}
|
|
}
|
|
# 424 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator, typename _Compare>
|
|
void
|
|
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
_Compare __comp)
|
|
{
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type
|
|
_ValueType;
|
|
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
|
|
_DistanceType;
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
if (__last - __first < 2)
|
|
return;
|
|
|
|
const _DistanceType __len = __last - __first;
|
|
_DistanceType __parent = (__len - 2) / 2;
|
|
while (true)
|
|
{
|
|
_ValueType __value = (*(__first + __parent));
|
|
std::__adjust_heap(__first, __parent, __len, (__value),
|
|
__comp);
|
|
if (__parent == 0)
|
|
return;
|
|
__parent--;
|
|
}
|
|
}
|
|
# 463 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator>
|
|
void
|
|
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
;
|
|
;
|
|
|
|
while (__last - __first > 1)
|
|
{
|
|
--__last;
|
|
std::__pop_heap(__first, __last, __last);
|
|
}
|
|
}
|
|
# 492 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
template<typename _RandomAccessIterator, typename _Compare>
|
|
void
|
|
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
|
|
_Compare __comp)
|
|
{
|
|
|
|
|
|
|
|
;
|
|
;
|
|
|
|
while (__last - __first > 1)
|
|
{
|
|
--__last;
|
|
std::__pop_heap(__first, __last, __last, __comp);
|
|
}
|
|
}
|
|
# 589 "/usr/include/c++/4.8.2/bits/stl_heap.h" 3
|
|
|
|
}
|
|
# 63 "/usr/include/c++/4.8.2/queue" 2 3
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_queue.h" 1 3
|
|
# 62 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 92 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
template<typename _Tp, typename _Sequence = deque<_Tp> >
|
|
class queue
|
|
{
|
|
|
|
typedef typename _Sequence::value_type _Sequence_value_type;
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Tp1, typename _Seq1>
|
|
friend bool
|
|
operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
|
|
|
|
template<typename _Tp1, typename _Seq1>
|
|
friend bool
|
|
operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);
|
|
|
|
public:
|
|
typedef typename _Sequence::value_type value_type;
|
|
typedef typename _Sequence::reference reference;
|
|
typedef typename _Sequence::const_reference const_reference;
|
|
typedef typename _Sequence::size_type size_type;
|
|
typedef _Sequence container_type;
|
|
|
|
protected:
|
|
# 126 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
_Sequence c;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
explicit
|
|
queue(const _Sequence& __c = _Sequence())
|
|
: c(__c) { }
|
|
# 149 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
bool
|
|
empty() const
|
|
{ return c.empty(); }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return c.size(); }
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
front()
|
|
{
|
|
;
|
|
return c.front();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
front() const
|
|
{
|
|
;
|
|
return c.front();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
back()
|
|
{
|
|
;
|
|
return c.back();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
back() const
|
|
{
|
|
;
|
|
return c.back();
|
|
}
|
|
# 211 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
void
|
|
push(const value_type& __x)
|
|
{ c.push_back(__x); }
|
|
# 237 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
void
|
|
pop()
|
|
{
|
|
;
|
|
c.pop_front();
|
|
}
|
|
# 253 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
};
|
|
# 266 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
template<typename _Tp, typename _Seq>
|
|
inline bool
|
|
operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
|
|
{ return __x.c == __y.c; }
|
|
# 284 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
template<typename _Tp, typename _Seq>
|
|
inline bool
|
|
operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
|
|
{ return __x.c < __y.c; }
|
|
|
|
|
|
template<typename _Tp, typename _Seq>
|
|
inline bool
|
|
operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Seq>
|
|
inline bool
|
|
operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Tp, typename _Seq>
|
|
inline bool
|
|
operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Tp, typename _Seq>
|
|
inline bool
|
|
operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
|
|
{ return !(__x < __y); }
|
|
# 365 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
template<typename _Tp, typename _Sequence = vector<_Tp>,
|
|
typename _Compare = less<typename _Sequence::value_type> >
|
|
class priority_queue
|
|
{
|
|
|
|
typedef typename _Sequence::value_type _Sequence_value_type;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
typedef typename _Sequence::value_type value_type;
|
|
typedef typename _Sequence::reference reference;
|
|
typedef typename _Sequence::const_reference const_reference;
|
|
typedef typename _Sequence::size_type size_type;
|
|
typedef _Sequence container_type;
|
|
|
|
protected:
|
|
|
|
_Sequence c;
|
|
_Compare comp;
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
explicit
|
|
priority_queue(const _Compare& __x = _Compare(),
|
|
const _Sequence& __s = _Sequence())
|
|
: c(__s), comp(__x)
|
|
{ std::make_heap(c.begin(), c.end(), comp); }
|
|
# 430 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
template<typename _InputIterator>
|
|
priority_queue(_InputIterator __first, _InputIterator __last,
|
|
const _Compare& __x = _Compare(),
|
|
const _Sequence& __s = _Sequence())
|
|
: c(__s), comp(__x)
|
|
{
|
|
;
|
|
c.insert(c.end(), __first, __last);
|
|
std::make_heap(c.begin(), c.end(), comp);
|
|
}
|
|
# 467 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
bool
|
|
empty() const
|
|
{ return c.empty(); }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return c.size(); }
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
top() const
|
|
{
|
|
;
|
|
return c.front();
|
|
}
|
|
# 495 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
void
|
|
push(const value_type& __x)
|
|
{
|
|
c.push_back(__x);
|
|
std::push_heap(c.begin(), c.end(), comp);
|
|
}
|
|
# 530 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
void
|
|
pop()
|
|
{
|
|
;
|
|
std::pop_heap(c.begin(), c.end(), comp);
|
|
c.pop_back();
|
|
}
|
|
# 548 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
};
|
|
# 566 "/usr/include/c++/4.8.2/bits/stl_queue.h" 3
|
|
|
|
}
|
|
# 65 "/usr/include/c++/4.8.2/queue" 2 3
|
|
# 13 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/c++/4.8.2/list" 1 3
|
|
# 58 "/usr/include/c++/4.8.2/list" 3
|
|
|
|
# 59 "/usr/include/c++/4.8.2/list" 3
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_list.h" 1 3
|
|
# 64 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
namespace __detail
|
|
{
|
|
|
|
# 77 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
struct _List_node_base
|
|
{
|
|
_List_node_base* _M_next;
|
|
_List_node_base* _M_prev;
|
|
|
|
static void
|
|
swap(_List_node_base& __x, _List_node_base& __y) throw();
|
|
|
|
void
|
|
_M_transfer(_List_node_base* const __first,
|
|
_List_node_base* const __last) throw();
|
|
|
|
void
|
|
_M_reverse() throw();
|
|
|
|
void
|
|
_M_hook(_List_node_base* const __position) throw();
|
|
|
|
void
|
|
_M_unhook() throw();
|
|
};
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct _List_node : public __detail::_List_node_base
|
|
{
|
|
|
|
_Tp _M_data;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct _List_iterator
|
|
{
|
|
typedef _List_iterator<_Tp> _Self;
|
|
typedef _List_node<_Tp> _Node;
|
|
|
|
typedef ptrdiff_t difference_type;
|
|
typedef std::bidirectional_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef _Tp* pointer;
|
|
typedef _Tp& reference;
|
|
|
|
_List_iterator()
|
|
: _M_node() { }
|
|
|
|
explicit
|
|
_List_iterator(__detail::_List_node_base* __x)
|
|
: _M_node(__x) { }
|
|
|
|
|
|
reference
|
|
operator*() const
|
|
{ return static_cast<_Node*>(_M_node)->_M_data; }
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
|
|
|
|
_Self&
|
|
operator++()
|
|
{
|
|
_M_node = _M_node->_M_next;
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator++(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _M_node->_M_next;
|
|
return __tmp;
|
|
}
|
|
|
|
_Self&
|
|
operator--()
|
|
{
|
|
_M_node = _M_node->_M_prev;
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator--(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _M_node->_M_prev;
|
|
return __tmp;
|
|
}
|
|
|
|
bool
|
|
operator==(const _Self& __x) const
|
|
{ return _M_node == __x._M_node; }
|
|
|
|
bool
|
|
operator!=(const _Self& __x) const
|
|
{ return _M_node != __x._M_node; }
|
|
|
|
|
|
__detail::_List_node_base* _M_node;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Tp>
|
|
struct _List_const_iterator
|
|
{
|
|
typedef _List_const_iterator<_Tp> _Self;
|
|
typedef const _List_node<_Tp> _Node;
|
|
typedef _List_iterator<_Tp> iterator;
|
|
|
|
typedef ptrdiff_t difference_type;
|
|
typedef std::bidirectional_iterator_tag iterator_category;
|
|
typedef _Tp value_type;
|
|
typedef const _Tp* pointer;
|
|
typedef const _Tp& reference;
|
|
|
|
_List_const_iterator()
|
|
: _M_node() { }
|
|
|
|
explicit
|
|
_List_const_iterator(const __detail::_List_node_base* __x)
|
|
: _M_node(__x) { }
|
|
|
|
_List_const_iterator(const iterator& __x)
|
|
: _M_node(__x._M_node) { }
|
|
|
|
|
|
|
|
reference
|
|
operator*() const
|
|
{ return static_cast<_Node*>(_M_node)->_M_data; }
|
|
|
|
pointer
|
|
operator->() const
|
|
{ return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
|
|
|
|
_Self&
|
|
operator++()
|
|
{
|
|
_M_node = _M_node->_M_next;
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator++(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _M_node->_M_next;
|
|
return __tmp;
|
|
}
|
|
|
|
_Self&
|
|
operator--()
|
|
{
|
|
_M_node = _M_node->_M_prev;
|
|
return *this;
|
|
}
|
|
|
|
_Self
|
|
operator--(int)
|
|
{
|
|
_Self __tmp = *this;
|
|
_M_node = _M_node->_M_prev;
|
|
return __tmp;
|
|
}
|
|
|
|
bool
|
|
operator==(const _Self& __x) const
|
|
{ return _M_node == __x._M_node; }
|
|
|
|
bool
|
|
operator!=(const _Self& __x) const
|
|
{ return _M_node != __x._M_node; }
|
|
|
|
|
|
const __detail::_List_node_base* _M_node;
|
|
};
|
|
|
|
template<typename _Val>
|
|
inline bool
|
|
operator==(const _List_iterator<_Val>& __x,
|
|
const _List_const_iterator<_Val>& __y)
|
|
{ return __x._M_node == __y._M_node; }
|
|
|
|
template<typename _Val>
|
|
inline bool
|
|
operator!=(const _List_iterator<_Val>& __x,
|
|
const _List_const_iterator<_Val>& __y)
|
|
{ return __x._M_node != __y._M_node; }
|
|
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
class _List_base
|
|
{
|
|
protected:
|
|
# 305 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
|
|
_Node_alloc_type;
|
|
|
|
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
|
|
|
|
struct _List_impl
|
|
: public _Node_alloc_type
|
|
{
|
|
__detail::_List_node_base _M_node;
|
|
|
|
_List_impl()
|
|
: _Node_alloc_type(), _M_node()
|
|
{ }
|
|
|
|
_List_impl(const _Node_alloc_type& __a)
|
|
: _Node_alloc_type(__a), _M_node()
|
|
{ }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
_List_impl _M_impl;
|
|
|
|
_List_node<_Tp>*
|
|
_M_get_node()
|
|
{ return _M_impl._Node_alloc_type::allocate(1); }
|
|
|
|
void
|
|
_M_put_node(_List_node<_Tp>* __p)
|
|
{ _M_impl._Node_alloc_type::deallocate(__p, 1); }
|
|
|
|
public:
|
|
typedef _Alloc allocator_type;
|
|
|
|
_Node_alloc_type&
|
|
_M_get_Node_allocator()
|
|
{ return *static_cast<_Node_alloc_type*>(&_M_impl); }
|
|
|
|
const _Node_alloc_type&
|
|
_M_get_Node_allocator() const
|
|
{ return *static_cast<const _Node_alloc_type*>(&_M_impl); }
|
|
|
|
_Tp_alloc_type
|
|
_M_get_Tp_allocator() const
|
|
{ return _Tp_alloc_type(_M_get_Node_allocator()); }
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_get_Node_allocator()); }
|
|
|
|
_List_base()
|
|
: _M_impl()
|
|
{ _M_init(); }
|
|
|
|
_List_base(const _Node_alloc_type& __a)
|
|
: _M_impl(__a)
|
|
{ _M_init(); }
|
|
# 377 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
~_List_base()
|
|
{ _M_clear(); }
|
|
|
|
void
|
|
_M_clear();
|
|
|
|
void
|
|
_M_init()
|
|
{
|
|
this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
|
|
this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
|
|
}
|
|
};
|
|
# 437 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
|
|
class list : protected _List_base<_Tp, _Alloc>
|
|
{
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
typedef _List_base<_Tp, _Alloc> _Base;
|
|
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
|
|
typedef typename _Base::_Node_alloc_type _Node_alloc_type;
|
|
|
|
public:
|
|
typedef _Tp value_type;
|
|
typedef typename _Tp_alloc_type::pointer pointer;
|
|
typedef typename _Tp_alloc_type::const_pointer const_pointer;
|
|
typedef typename _Tp_alloc_type::reference reference;
|
|
typedef typename _Tp_alloc_type::const_reference const_reference;
|
|
typedef _List_iterator<_Tp> iterator;
|
|
typedef _List_const_iterator<_Tp> const_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
typedef _Alloc allocator_type;
|
|
|
|
protected:
|
|
|
|
|
|
typedef _List_node<_Tp> _Node;
|
|
|
|
using _Base::_M_impl;
|
|
using _Base::_M_put_node;
|
|
using _Base::_M_get_node;
|
|
using _Base::_M_get_Tp_allocator;
|
|
using _Base::_M_get_Node_allocator;
|
|
# 481 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
_Node*
|
|
_M_create_node(const value_type& __x)
|
|
{
|
|
_Node* __p = this->_M_get_node();
|
|
try
|
|
{
|
|
_M_get_Tp_allocator().construct
|
|
(std::__addressof(__p->_M_data), __x);
|
|
}
|
|
catch(...)
|
|
{
|
|
_M_put_node(__p);
|
|
throw;
|
|
}
|
|
return __p;
|
|
}
|
|
# 517 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
public:
|
|
|
|
|
|
|
|
|
|
|
|
list()
|
|
: _Base() { }
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
list(const allocator_type& __a)
|
|
: _Base(_Node_alloc_type(__a)) { }
|
|
# 568 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
explicit
|
|
list(size_type __n, const value_type& __value = value_type(),
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(_Node_alloc_type(__a))
|
|
{ _M_fill_initialize(__n, __value); }
|
|
# 582 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
list(const list& __x)
|
|
: _Base(__x._M_get_Node_allocator())
|
|
{ _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
|
|
# 629 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _InputIterator>
|
|
list(_InputIterator __first, _InputIterator __last,
|
|
const allocator_type& __a = allocator_type())
|
|
: _Base(_Node_alloc_type(__a))
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_initialize_dispatch(__first, __last, _Integral());
|
|
}
|
|
# 655 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
list&
|
|
operator=(const list& __x);
|
|
# 701 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
assign(size_type __n, const value_type& __val)
|
|
{ _M_fill_assign(__n, __val); }
|
|
# 724 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
assign(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
|
|
typedef typename std::__is_integer<_InputIterator>::__type _Integral;
|
|
_M_assign_dispatch(__first, __last, _Integral());
|
|
}
|
|
# 748 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return _Base::get_allocator(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin()
|
|
{ return iterator(this->_M_impl._M_node._M_next); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
begin() const
|
|
{ return const_iterator(this->_M_impl._M_node._M_next); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end()
|
|
{ return iterator(&this->_M_impl._M_node); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_iterator
|
|
end() const
|
|
{ return const_iterator(&this->_M_impl._M_node); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin()
|
|
{ return reverse_iterator(end()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rbegin() const
|
|
{ return const_reverse_iterator(end()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend()
|
|
{ return reverse_iterator(begin()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const_reverse_iterator
|
|
rend() const
|
|
{ return const_reverse_iterator(begin()); }
|
|
# 867 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
bool
|
|
empty() const
|
|
{ return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return std::distance(begin(), end()); }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_get_Node_allocator().max_size(); }
|
|
# 917 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
resize(size_type __new_size, value_type __x = value_type());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
front()
|
|
{ return *begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
front() const
|
|
{ return *begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
reference
|
|
back()
|
|
{
|
|
iterator __tmp = end();
|
|
--__tmp;
|
|
return *__tmp;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const_reference
|
|
back() const
|
|
{
|
|
const_iterator __tmp = end();
|
|
--__tmp;
|
|
return *__tmp;
|
|
}
|
|
# 973 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
push_front(const value_type& __x)
|
|
{ this->_M_insert(begin(), __x); }
|
|
# 1000 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
pop_front()
|
|
{ this->_M_erase(begin()); }
|
|
# 1014 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
push_back(const value_type& __x)
|
|
{ this->_M_insert(end(), __x); }
|
|
# 1040 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
pop_back()
|
|
{ this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
|
|
# 1073 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
iterator
|
|
insert(iterator __position, const value_type& __x);
|
|
# 1122 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
insert(iterator __position, size_type __n, const value_type& __x)
|
|
{
|
|
list __tmp(__n, __x, get_allocator());
|
|
splice(__position, __tmp);
|
|
}
|
|
# 1146 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _InputIterator>
|
|
|
|
void
|
|
insert(iterator __position, _InputIterator __first,
|
|
_InputIterator __last)
|
|
{
|
|
list __tmp(__first, __last, get_allocator());
|
|
splice(__position, __tmp);
|
|
}
|
|
# 1171 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
iterator
|
|
erase(iterator __position);
|
|
# 1192 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
iterator
|
|
erase(iterator __first, iterator __last)
|
|
{
|
|
while (__first != __last)
|
|
__first = erase(__first);
|
|
return __last;
|
|
}
|
|
# 1209 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
swap(list& __x)
|
|
{
|
|
__detail::_List_node_base::swap(this->_M_impl._M_node,
|
|
__x._M_impl._M_node);
|
|
|
|
|
|
|
|
std::__alloc_swap<typename _Base::_Node_alloc_type>::
|
|
_S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
clear()
|
|
{
|
|
_Base::_M_clear();
|
|
_Base::_M_init();
|
|
}
|
|
# 1246 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
|
|
|
|
|
|
splice(iterator __position, list& __x)
|
|
|
|
{
|
|
if (!__x.empty())
|
|
{
|
|
_M_check_equal_allocators(__x);
|
|
|
|
this->_M_transfer(__position, __x.begin(), __x.end());
|
|
}
|
|
}
|
|
# 1276 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
|
|
|
|
|
|
splice(iterator __position, list& __x, iterator __i)
|
|
|
|
{
|
|
iterator __j = __i;
|
|
++__j;
|
|
if (__position == __i || __position == __j)
|
|
return;
|
|
|
|
if (this != &__x)
|
|
_M_check_equal_allocators(__x);
|
|
|
|
this->_M_transfer(__position, __i, __j);
|
|
}
|
|
# 1312 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
|
|
|
|
|
|
|
|
splice(iterator __position, list& __x, iterator __first,
|
|
iterator __last)
|
|
|
|
{
|
|
if (__first != __last)
|
|
{
|
|
if (this != &__x)
|
|
_M_check_equal_allocators(__x);
|
|
|
|
this->_M_transfer(__position, __first, __last);
|
|
}
|
|
}
|
|
# 1347 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
remove(const _Tp& __value);
|
|
# 1361 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _Predicate>
|
|
void
|
|
remove_if(_Predicate);
|
|
# 1375 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
unique();
|
|
# 1390 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _BinaryPredicate>
|
|
void
|
|
unique(_BinaryPredicate);
|
|
# 1411 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
merge(list& __x);
|
|
# 1438 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _StrictWeakOrdering>
|
|
void
|
|
merge(list& __x, _StrictWeakOrdering __comp);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
reverse()
|
|
{ this->_M_impl._M_node._M_reverse(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
sort();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _StrictWeakOrdering>
|
|
void
|
|
sort(_StrictWeakOrdering);
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename _Integer>
|
|
void
|
|
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
|
|
{ _M_fill_initialize(static_cast<size_type>(__n), __x); }
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type)
|
|
{
|
|
for (; __first != __last; ++__first)
|
|
|
|
|
|
|
|
push_back(*__first);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
_M_fill_initialize(size_type __n, const value_type& __x)
|
|
{
|
|
for (; __n; --__n)
|
|
push_back(__x);
|
|
}
|
|
# 1526 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _Integer>
|
|
void
|
|
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
|
|
{ _M_fill_assign(__n, __val); }
|
|
|
|
|
|
template<typename _InputIterator>
|
|
void
|
|
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
|
|
__false_type);
|
|
|
|
|
|
|
|
void
|
|
_M_fill_assign(size_type __n, const value_type& __val);
|
|
|
|
|
|
|
|
void
|
|
_M_transfer(iterator __position, iterator __first, iterator __last)
|
|
{ __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
|
|
|
|
|
|
|
|
void
|
|
_M_insert(iterator __position, const value_type& __x)
|
|
{
|
|
_Node* __tmp = _M_create_node(__x);
|
|
__tmp->_M_hook(__position._M_node);
|
|
}
|
|
# 1567 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
void
|
|
_M_erase(iterator __position)
|
|
{
|
|
__position._M_node->_M_unhook();
|
|
_Node* __n = static_cast<_Node*>(__position._M_node);
|
|
|
|
|
|
|
|
_M_get_Tp_allocator().destroy(std::__addressof(__n->_M_data));
|
|
|
|
_M_put_node(__n);
|
|
}
|
|
|
|
|
|
void
|
|
_M_check_equal_allocators(list& __x)
|
|
{
|
|
if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
|
|
_S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
|
|
__throw_runtime_error(("list::_M_check_equal_allocators"));
|
|
}
|
|
};
|
|
# 1600 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
|
|
{
|
|
typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
|
|
const_iterator __end1 = __x.end();
|
|
const_iterator __end2 = __y.end();
|
|
|
|
const_iterator __i1 = __x.begin();
|
|
const_iterator __i2 = __y.begin();
|
|
while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
|
|
{
|
|
++__i1;
|
|
++__i2;
|
|
}
|
|
return __i1 == __end1 && __i2 == __end2;
|
|
}
|
|
# 1629 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
|
|
{ return std::lexicographical_compare(__x.begin(), __x.end(),
|
|
__y.begin(), __y.end()); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline bool
|
|
operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
inline void
|
|
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
}
|
|
# 64 "/usr/include/c++/4.8.2/list" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/list.tcc" 1 3
|
|
# 59 "/usr/include/c++/4.8.2/bits/list.tcc" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
_List_base<_Tp, _Alloc>::
|
|
_M_clear()
|
|
{
|
|
typedef _List_node<_Tp> _Node;
|
|
_Node* __cur = static_cast<_Node*>(_M_impl._M_node._M_next);
|
|
while (__cur != &_M_impl._M_node)
|
|
{
|
|
_Node* __tmp = __cur;
|
|
__cur = static_cast<_Node*>(__cur->_M_next);
|
|
|
|
|
|
|
|
_M_get_Tp_allocator().destroy(std::__addressof(__tmp->_M_data));
|
|
|
|
_M_put_node(__tmp);
|
|
}
|
|
}
|
|
# 96 "/usr/include/c++/4.8.2/bits/list.tcc" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
typename list<_Tp, _Alloc>::iterator
|
|
list<_Tp, _Alloc>::
|
|
insert(iterator __position, const value_type& __x)
|
|
{
|
|
_Node* __tmp = _M_create_node(__x);
|
|
__tmp->_M_hook(__position._M_node);
|
|
return iterator(__tmp);
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
typename list<_Tp, _Alloc>::iterator
|
|
list<_Tp, _Alloc>::
|
|
erase(iterator __position)
|
|
{
|
|
iterator __ret = iterator(__position._M_node->_M_next);
|
|
_M_erase(__position);
|
|
return __ret;
|
|
}
|
|
# 166 "/usr/include/c++/4.8.2/bits/list.tcc" 3
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
resize(size_type __new_size, value_type __x)
|
|
{
|
|
iterator __i = begin();
|
|
size_type __len = 0;
|
|
for (; __i != end() && __len < __new_size; ++__i, ++__len)
|
|
;
|
|
if (__len == __new_size)
|
|
erase(__i, end());
|
|
else
|
|
insert(end(), __new_size - __len, __x);
|
|
}
|
|
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
list<_Tp, _Alloc>&
|
|
list<_Tp, _Alloc>::
|
|
operator=(const list& __x)
|
|
{
|
|
if (this != &__x)
|
|
{
|
|
iterator __first1 = begin();
|
|
iterator __last1 = end();
|
|
const_iterator __first2 = __x.begin();
|
|
const_iterator __last2 = __x.end();
|
|
for (; __first1 != __last1 && __first2 != __last2;
|
|
++__first1, ++__first2)
|
|
*__first1 = *__first2;
|
|
if (__first2 == __last2)
|
|
erase(__first1, __last1);
|
|
else
|
|
insert(__last1, __first2, __last2);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
_M_fill_assign(size_type __n, const value_type& __val)
|
|
{
|
|
iterator __i = begin();
|
|
for (; __i != end() && __n > 0; ++__i, --__n)
|
|
*__i = __val;
|
|
if (__n > 0)
|
|
insert(end(), __n, __val);
|
|
else
|
|
erase(__i, end());
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template <typename _InputIterator>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
_M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
|
|
__false_type)
|
|
{
|
|
iterator __first1 = begin();
|
|
iterator __last1 = end();
|
|
for (; __first1 != __last1 && __first2 != __last2;
|
|
++__first1, ++__first2)
|
|
*__first1 = *__first2;
|
|
if (__first2 == __last2)
|
|
erase(__first1, __last1);
|
|
else
|
|
insert(__last1, __first2, __last2);
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
remove(const value_type& __value)
|
|
{
|
|
iterator __first = begin();
|
|
iterator __last = end();
|
|
iterator __extra = __last;
|
|
while (__first != __last)
|
|
{
|
|
iterator __next = __first;
|
|
++__next;
|
|
if (*__first == __value)
|
|
{
|
|
|
|
|
|
|
|
if (std::__addressof(*__first) != std::__addressof(__value))
|
|
_M_erase(__first);
|
|
else
|
|
__extra = __first;
|
|
}
|
|
__first = __next;
|
|
}
|
|
if (__extra != __last)
|
|
_M_erase(__extra);
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
unique()
|
|
{
|
|
iterator __first = begin();
|
|
iterator __last = end();
|
|
if (__first == __last)
|
|
return;
|
|
iterator __next = __first;
|
|
while (++__next != __last)
|
|
{
|
|
if (*__first == *__next)
|
|
_M_erase(__next);
|
|
else
|
|
__first = __next;
|
|
__next = __first;
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
|
|
|
|
|
|
merge(list& __x)
|
|
|
|
{
|
|
|
|
|
|
if (this != &__x)
|
|
{
|
|
_M_check_equal_allocators(__x);
|
|
|
|
iterator __first1 = begin();
|
|
iterator __last1 = end();
|
|
iterator __first2 = __x.begin();
|
|
iterator __last2 = __x.end();
|
|
while (__first1 != __last1 && __first2 != __last2)
|
|
if (*__first2 < *__first1)
|
|
{
|
|
iterator __next = __first2;
|
|
_M_transfer(__first1, __first2, ++__next);
|
|
__first2 = __next;
|
|
}
|
|
else
|
|
++__first1;
|
|
if (__first2 != __last2)
|
|
_M_transfer(__last1, __first2, __last2);
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template <typename _StrictWeakOrdering>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
|
|
|
|
|
|
merge(list& __x, _StrictWeakOrdering __comp)
|
|
|
|
{
|
|
|
|
|
|
if (this != &__x)
|
|
{
|
|
_M_check_equal_allocators(__x);
|
|
|
|
iterator __first1 = begin();
|
|
iterator __last1 = end();
|
|
iterator __first2 = __x.begin();
|
|
iterator __last2 = __x.end();
|
|
while (__first1 != __last1 && __first2 != __last2)
|
|
if (__comp(*__first2, *__first1))
|
|
{
|
|
iterator __next = __first2;
|
|
_M_transfer(__first1, __first2, ++__next);
|
|
__first2 = __next;
|
|
}
|
|
else
|
|
++__first1;
|
|
if (__first2 != __last2)
|
|
_M_transfer(__last1, __first2, __last2);
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
sort()
|
|
{
|
|
|
|
if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
|
|
&& this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
|
|
{
|
|
list __carry;
|
|
list __tmp[64];
|
|
list * __fill = &__tmp[0];
|
|
list * __counter;
|
|
|
|
do
|
|
{
|
|
__carry.splice(__carry.begin(), *this, begin());
|
|
|
|
for(__counter = &__tmp[0];
|
|
__counter != __fill && !__counter->empty();
|
|
++__counter)
|
|
{
|
|
__counter->merge(__carry);
|
|
__carry.swap(*__counter);
|
|
}
|
|
__carry.swap(*__counter);
|
|
if (__counter == __fill)
|
|
++__fill;
|
|
}
|
|
while ( !empty() );
|
|
|
|
for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
|
|
__counter->merge(*(__counter - 1));
|
|
swap( *(__fill - 1) );
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template <typename _Predicate>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
remove_if(_Predicate __pred)
|
|
{
|
|
iterator __first = begin();
|
|
iterator __last = end();
|
|
while (__first != __last)
|
|
{
|
|
iterator __next = __first;
|
|
++__next;
|
|
if (__pred(*__first))
|
|
_M_erase(__first);
|
|
__first = __next;
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template <typename _BinaryPredicate>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
unique(_BinaryPredicate __binary_pred)
|
|
{
|
|
iterator __first = begin();
|
|
iterator __last = end();
|
|
if (__first == __last)
|
|
return;
|
|
iterator __next = __first;
|
|
while (++__next != __last)
|
|
{
|
|
if (__binary_pred(*__first, *__next))
|
|
_M_erase(__next);
|
|
else
|
|
__first = __next;
|
|
__next = __first;
|
|
}
|
|
}
|
|
|
|
template<typename _Tp, typename _Alloc>
|
|
template <typename _StrictWeakOrdering>
|
|
void
|
|
list<_Tp, _Alloc>::
|
|
sort(_StrictWeakOrdering __comp)
|
|
{
|
|
|
|
if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
|
|
&& this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
|
|
{
|
|
list __carry;
|
|
list __tmp[64];
|
|
list * __fill = &__tmp[0];
|
|
list * __counter;
|
|
|
|
do
|
|
{
|
|
__carry.splice(__carry.begin(), *this, begin());
|
|
|
|
for(__counter = &__tmp[0];
|
|
__counter != __fill && !__counter->empty();
|
|
++__counter)
|
|
{
|
|
__counter->merge(__carry, __comp);
|
|
__carry.swap(*__counter);
|
|
}
|
|
__carry.swap(*__counter);
|
|
if (__counter == __fill)
|
|
++__fill;
|
|
}
|
|
while ( !empty() );
|
|
|
|
for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
|
|
__counter->merge(*(__counter - 1), __comp);
|
|
swap(*(__fill - 1));
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
# 65 "/usr/include/c++/4.8.2/list" 2 3
|
|
# 14 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/c++/4.8.2/set" 1 3
|
|
# 58 "/usr/include/c++/4.8.2/set" 3
|
|
|
|
# 59 "/usr/include/c++/4.8.2/set" 3
|
|
|
|
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_set.h" 1 3
|
|
# 64 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 88 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
template<typename _Key, typename _Compare = std::less<_Key>,
|
|
typename _Alloc = std::allocator<_Key> >
|
|
class set
|
|
{
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
typedef _Key key_type;
|
|
typedef _Key value_type;
|
|
typedef _Compare key_compare;
|
|
typedef _Compare value_compare;
|
|
typedef _Alloc allocator_type;
|
|
|
|
|
|
private:
|
|
typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
|
|
|
|
typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
|
|
key_compare, _Key_alloc_type> _Rep_type;
|
|
_Rep_type _M_t;
|
|
|
|
public:
|
|
|
|
|
|
typedef typename _Key_alloc_type::pointer pointer;
|
|
typedef typename _Key_alloc_type::const_pointer const_pointer;
|
|
typedef typename _Key_alloc_type::reference reference;
|
|
typedef typename _Key_alloc_type::const_reference const_reference;
|
|
|
|
|
|
|
|
typedef typename _Rep_type::const_iterator iterator;
|
|
typedef typename _Rep_type::const_iterator const_iterator;
|
|
typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
|
|
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
|
typedef typename _Rep_type::size_type size_type;
|
|
typedef typename _Rep_type::difference_type difference_type;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
set()
|
|
: _M_t() { }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
set(const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Key_alloc_type(__a)) { }
|
|
# 162 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
template<typename _InputIterator>
|
|
set(_InputIterator __first, _InputIterator __last)
|
|
: _M_t()
|
|
{ _M_t._M_insert_unique(__first, __last); }
|
|
# 179 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
template<typename _InputIterator>
|
|
set(_InputIterator __first, _InputIterator __last,
|
|
const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Key_alloc_type(__a))
|
|
{ _M_t._M_insert_unique(__first, __last); }
|
|
# 193 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
set(const set& __x)
|
|
: _M_t(__x._M_t) { }
|
|
# 232 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
set&
|
|
operator=(const set& __x)
|
|
{
|
|
_M_t = __x._M_t;
|
|
return *this;
|
|
}
|
|
# 280 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
key_compare
|
|
key_comp() const
|
|
{ return _M_t.key_comp(); }
|
|
|
|
value_compare
|
|
value_comp() const
|
|
{ return _M_t.key_comp(); }
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_t.get_allocator()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin() const
|
|
{ return _M_t.begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end() const
|
|
{ return _M_t.end(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin() const
|
|
{ return _M_t.rbegin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend() const
|
|
{ return _M_t.rend(); }
|
|
# 367 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
bool
|
|
empty() const
|
|
{ return _M_t.empty(); }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return _M_t.size(); }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_t.max_size(); }
|
|
# 392 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
void
|
|
swap(set& __x)
|
|
{ _M_t.swap(__x._M_t); }
|
|
# 459 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
std::pair<iterator, bool>
|
|
insert(const value_type& __x)
|
|
{
|
|
std::pair<typename _Rep_type::iterator, bool> __p =
|
|
_M_t._M_insert_unique(__x);
|
|
return std::pair<iterator, bool>(__p.first, __p.second);
|
|
}
|
|
# 496 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
iterator
|
|
insert(const_iterator __position, const value_type& __x)
|
|
{ return _M_t._M_insert_unique_(__position, __x); }
|
|
# 515 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(_InputIterator __first, _InputIterator __last)
|
|
{ _M_t._M_insert_unique(__first, __last); }
|
|
# 564 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
void
|
|
erase(iterator __position)
|
|
{ _M_t.erase(__position); }
|
|
# 580 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
size_type
|
|
erase(const key_type& __x)
|
|
{ return _M_t.erase(__x); }
|
|
# 618 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
void
|
|
erase(iterator __first, iterator __last)
|
|
{ _M_t.erase(__first, __last); }
|
|
# 629 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
void
|
|
clear()
|
|
{ _M_t.clear(); }
|
|
# 643 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
size_type
|
|
count(const key_type& __x) const
|
|
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
|
|
# 661 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
iterator
|
|
find(const key_type& __x)
|
|
{ return _M_t.find(__x); }
|
|
|
|
const_iterator
|
|
find(const key_type& __x) const
|
|
{ return _M_t.find(__x); }
|
|
# 682 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
iterator
|
|
lower_bound(const key_type& __x)
|
|
{ return _M_t.lower_bound(__x); }
|
|
|
|
const_iterator
|
|
lower_bound(const key_type& __x) const
|
|
{ return _M_t.lower_bound(__x); }
|
|
# 698 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
iterator
|
|
upper_bound(const key_type& __x)
|
|
{ return _M_t.upper_bound(__x); }
|
|
|
|
const_iterator
|
|
upper_bound(const key_type& __x) const
|
|
{ return _M_t.upper_bound(__x); }
|
|
# 723 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
std::pair<iterator, iterator>
|
|
equal_range(const key_type& __x)
|
|
{ return _M_t.equal_range(__x); }
|
|
|
|
std::pair<const_iterator, const_iterator>
|
|
equal_range(const key_type& __x) const
|
|
{ return _M_t.equal_range(__x); }
|
|
|
|
|
|
template<typename _K1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
|
|
|
|
template<typename _K1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
|
|
};
|
|
# 752 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator==(const set<_Key, _Compare, _Alloc>& __x,
|
|
const set<_Key, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t == __y._M_t; }
|
|
# 769 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<(const set<_Key, _Compare, _Alloc>& __x,
|
|
const set<_Key, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t < __y._M_t; }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator!=(const set<_Key, _Compare, _Alloc>& __x,
|
|
const set<_Key, _Compare, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>(const set<_Key, _Compare, _Alloc>& __x,
|
|
const set<_Key, _Compare, _Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<=(const set<_Key, _Compare, _Alloc>& __x,
|
|
const set<_Key, _Compare, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>=(const set<_Key, _Compare, _Alloc>& __x,
|
|
const set<_Key, _Compare, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline void
|
|
swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
}
|
|
# 62 "/usr/include/c++/4.8.2/set" 2 3
|
|
# 1 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 1 3
|
|
# 64 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
namespace std __attribute__ ((__visibility__ ("default")))
|
|
{
|
|
|
|
# 90 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
template <typename _Key, typename _Compare = std::less<_Key>,
|
|
typename _Alloc = std::allocator<_Key> >
|
|
class multiset
|
|
{
|
|
|
|
typedef typename _Alloc::value_type _Alloc_value_type;
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
typedef _Key key_type;
|
|
typedef _Key value_type;
|
|
typedef _Compare key_compare;
|
|
typedef _Compare value_compare;
|
|
typedef _Alloc allocator_type;
|
|
|
|
private:
|
|
|
|
typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
|
|
|
|
typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
|
|
key_compare, _Key_alloc_type> _Rep_type;
|
|
|
|
_Rep_type _M_t;
|
|
|
|
public:
|
|
typedef typename _Key_alloc_type::pointer pointer;
|
|
typedef typename _Key_alloc_type::const_pointer const_pointer;
|
|
typedef typename _Key_alloc_type::reference reference;
|
|
typedef typename _Key_alloc_type::const_reference const_reference;
|
|
|
|
|
|
|
|
typedef typename _Rep_type::const_iterator iterator;
|
|
typedef typename _Rep_type::const_iterator const_iterator;
|
|
typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
|
|
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
|
|
typedef typename _Rep_type::size_type size_type;
|
|
typedef typename _Rep_type::difference_type difference_type;
|
|
|
|
|
|
|
|
|
|
|
|
multiset()
|
|
: _M_t() { }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
explicit
|
|
multiset(const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Key_alloc_type(__a)) { }
|
|
# 159 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
template<typename _InputIterator>
|
|
multiset(_InputIterator __first, _InputIterator __last)
|
|
: _M_t()
|
|
{ _M_t._M_insert_equal(__first, __last); }
|
|
# 175 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
template<typename _InputIterator>
|
|
multiset(_InputIterator __first, _InputIterator __last,
|
|
const _Compare& __comp,
|
|
const allocator_type& __a = allocator_type())
|
|
: _M_t(__comp, _Key_alloc_type(__a))
|
|
{ _M_t._M_insert_equal(__first, __last); }
|
|
# 189 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
multiset(const multiset& __x)
|
|
: _M_t(__x._M_t) { }
|
|
# 228 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
multiset&
|
|
operator=(const multiset& __x)
|
|
{
|
|
_M_t = __x._M_t;
|
|
return *this;
|
|
}
|
|
# 277 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
key_compare
|
|
key_comp() const
|
|
{ return _M_t.key_comp(); }
|
|
|
|
value_compare
|
|
value_comp() const
|
|
{ return _M_t.key_comp(); }
|
|
|
|
allocator_type
|
|
get_allocator() const
|
|
{ return allocator_type(_M_t.get_allocator()); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
begin() const
|
|
{ return _M_t.begin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
iterator
|
|
end() const
|
|
{ return _M_t.end(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rbegin() const
|
|
{ return _M_t.rbegin(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
reverse_iterator
|
|
rend() const
|
|
{ return _M_t.rend(); }
|
|
# 364 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
bool
|
|
empty() const
|
|
{ return _M_t.empty(); }
|
|
|
|
|
|
size_type
|
|
size() const
|
|
{ return _M_t.size(); }
|
|
|
|
|
|
size_type
|
|
max_size() const
|
|
{ return _M_t.max_size(); }
|
|
# 389 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
void
|
|
swap(multiset& __x)
|
|
{ _M_t.swap(__x._M_t); }
|
|
# 453 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
iterator
|
|
insert(const value_type& __x)
|
|
{ return _M_t._M_insert_equal(__x); }
|
|
# 483 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
iterator
|
|
insert(const_iterator __position, const value_type& __x)
|
|
{ return _M_t._M_insert_equal_(__position, __x); }
|
|
# 501 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
template<typename _InputIterator>
|
|
void
|
|
insert(_InputIterator __first, _InputIterator __last)
|
|
{ _M_t._M_insert_equal(__first, __last); }
|
|
# 550 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
void
|
|
erase(iterator __position)
|
|
{ _M_t.erase(__position); }
|
|
# 566 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
size_type
|
|
erase(const key_type& __x)
|
|
{ return _M_t.erase(__x); }
|
|
# 604 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
void
|
|
erase(iterator __first, iterator __last)
|
|
{ _M_t.erase(__first, __last); }
|
|
# 615 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
void
|
|
clear()
|
|
{ _M_t.clear(); }
|
|
# 626 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
size_type
|
|
count(const key_type& __x) const
|
|
{ return _M_t.count(__x); }
|
|
# 644 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
iterator
|
|
find(const key_type& __x)
|
|
{ return _M_t.find(__x); }
|
|
|
|
const_iterator
|
|
find(const key_type& __x) const
|
|
{ return _M_t.find(__x); }
|
|
# 665 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
iterator
|
|
lower_bound(const key_type& __x)
|
|
{ return _M_t.lower_bound(__x); }
|
|
|
|
const_iterator
|
|
lower_bound(const key_type& __x) const
|
|
{ return _M_t.lower_bound(__x); }
|
|
# 681 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
iterator
|
|
upper_bound(const key_type& __x)
|
|
{ return _M_t.upper_bound(__x); }
|
|
|
|
const_iterator
|
|
upper_bound(const key_type& __x) const
|
|
{ return _M_t.upper_bound(__x); }
|
|
# 706 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
std::pair<iterator, iterator>
|
|
equal_range(const key_type& __x)
|
|
{ return _M_t.equal_range(__x); }
|
|
|
|
std::pair<const_iterator, const_iterator>
|
|
equal_range(const key_type& __x) const
|
|
{ return _M_t.equal_range(__x); }
|
|
|
|
|
|
template<typename _K1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator==(const multiset<_K1, _C1, _A1>&,
|
|
const multiset<_K1, _C1, _A1>&);
|
|
|
|
template<typename _K1, typename _C1, typename _A1>
|
|
friend bool
|
|
operator< (const multiset<_K1, _C1, _A1>&,
|
|
const multiset<_K1, _C1, _A1>&);
|
|
};
|
|
# 737 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator==(const multiset<_Key, _Compare, _Alloc>& __x,
|
|
const multiset<_Key, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t == __y._M_t; }
|
|
# 754 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<(const multiset<_Key, _Compare, _Alloc>& __x,
|
|
const multiset<_Key, _Compare, _Alloc>& __y)
|
|
{ return __x._M_t < __y._M_t; }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
|
|
const multiset<_Key, _Compare, _Alloc>& __y)
|
|
{ return !(__x == __y); }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>(const multiset<_Key,_Compare,_Alloc>& __x,
|
|
const multiset<_Key,_Compare,_Alloc>& __y)
|
|
{ return __y < __x; }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
|
|
const multiset<_Key, _Compare, _Alloc>& __y)
|
|
{ return !(__y < __x); }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline bool
|
|
operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
|
|
const multiset<_Key, _Compare, _Alloc>& __y)
|
|
{ return !(__x < __y); }
|
|
|
|
|
|
template<typename _Key, typename _Compare, typename _Alloc>
|
|
inline void
|
|
swap(multiset<_Key, _Compare, _Alloc>& __x,
|
|
multiset<_Key, _Compare, _Alloc>& __y)
|
|
{ __x.swap(__y); }
|
|
|
|
|
|
}
|
|
# 63 "/usr/include/c++/4.8.2/set" 2 3
|
|
# 15 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/unistd.h" 1 3 4
|
|
# 27 "/usr/include/unistd.h" 3 4
|
|
extern "C" {
|
|
# 202 "/usr/include/unistd.h" 3 4
|
|
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
|
|
# 203 "/usr/include/unistd.h" 2 3 4
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/environments.h" 1 3 4
|
|
# 22 "/usr/include/bits/environments.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 23 "/usr/include/bits/environments.h" 2 3 4
|
|
# 207 "/usr/include/unistd.h" 2 3 4
|
|
# 220 "/usr/include/unistd.h" 3 4
|
|
typedef __ssize_t ssize_t;
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 227 "/usr/include/unistd.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
typedef __gid_t gid_t;
|
|
|
|
|
|
|
|
|
|
typedef __uid_t uid_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef __off_t off_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __off64_t off64_t;
|
|
|
|
|
|
|
|
|
|
typedef __useconds_t useconds_t;
|
|
# 267 "/usr/include/unistd.h" 3 4
|
|
typedef __intptr_t intptr_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __socklen_t socklen_t;
|
|
# 287 "/usr/include/unistd.h" 3 4
|
|
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
extern int euidaccess (const char *__name, int __type)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int eaccess (const char *__name, int __type)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
|
|
throw () __attribute__ ((__nonnull__ (2))) ;
|
|
# 334 "/usr/include/unistd.h" 3 4
|
|
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
|
|
# 345 "/usr/include/unistd.h" 3 4
|
|
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int close (int __fd);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
|
|
# 376 "/usr/include/unistd.h" 3 4
|
|
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
|
|
__off_t __offset) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
|
|
__off_t __offset) ;
|
|
# 404 "/usr/include/unistd.h" 3 4
|
|
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
|
|
__off64_t __offset) ;
|
|
|
|
|
|
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
|
|
__off64_t __offset) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int pipe (int __pipedes[2]) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
|
|
# 432 "/usr/include/unistd.h" 3 4
|
|
extern unsigned int alarm (unsigned int __seconds) throw ();
|
|
# 444 "/usr/include/unistd.h" 3 4
|
|
extern unsigned int sleep (unsigned int __seconds);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int usleep (__useconds_t __useconds);
|
|
# 469 "/usr/include/unistd.h" 3 4
|
|
extern int pause (void);
|
|
|
|
|
|
|
|
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
|
|
__gid_t __group, int __flag)
|
|
throw () __attribute__ ((__nonnull__ (2))) ;
|
|
|
|
|
|
|
|
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
extern int fchdir (int __fd) throw () ;
|
|
# 511 "/usr/include/unistd.h" 3 4
|
|
extern char *getcwd (char *__buf, size_t __size) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern char *get_current_dir_name (void) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *getwd (char *__buf)
|
|
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
|
|
|
|
|
|
|
|
|
|
extern int dup (int __fd) throw () ;
|
|
|
|
|
|
extern int dup2 (int __fd, int __fd2) throw ();
|
|
|
|
|
|
|
|
|
|
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
|
|
|
|
|
|
|
|
extern char **__environ;
|
|
|
|
extern char **environ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int execve (const char *__path, char *const __argv[],
|
|
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
|
|
extern int execv (const char *__path, char *const __argv[])
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int execle (const char *__path, const char *__arg, ...)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int execl (const char *__path, const char *__arg, ...)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern int execvp (const char *__file, char *const __argv[])
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern int execlp (const char *__file, const char *__arg, ...)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern int execvpe (const char *__file, char *const __argv[],
|
|
char *const __envp[])
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int nice (int __inc) throw () ;
|
|
|
|
|
|
|
|
|
|
extern void _exit (int __status) __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/confname.h" 1 3 4
|
|
# 25 "/usr/include/bits/confname.h" 3 4
|
|
enum
|
|
{
|
|
_PC_LINK_MAX,
|
|
|
|
_PC_MAX_CANON,
|
|
|
|
_PC_MAX_INPUT,
|
|
|
|
_PC_NAME_MAX,
|
|
|
|
_PC_PATH_MAX,
|
|
|
|
_PC_PIPE_BUF,
|
|
|
|
_PC_CHOWN_RESTRICTED,
|
|
|
|
_PC_NO_TRUNC,
|
|
|
|
_PC_VDISABLE,
|
|
|
|
_PC_SYNC_IO,
|
|
|
|
_PC_ASYNC_IO,
|
|
|
|
_PC_PRIO_IO,
|
|
|
|
_PC_SOCK_MAXBUF,
|
|
|
|
_PC_FILESIZEBITS,
|
|
|
|
_PC_REC_INCR_XFER_SIZE,
|
|
|
|
_PC_REC_MAX_XFER_SIZE,
|
|
|
|
_PC_REC_MIN_XFER_SIZE,
|
|
|
|
_PC_REC_XFER_ALIGN,
|
|
|
|
_PC_ALLOC_SIZE_MIN,
|
|
|
|
_PC_SYMLINK_MAX,
|
|
|
|
_PC_2_SYMLINKS
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
_SC_ARG_MAX,
|
|
|
|
_SC_CHILD_MAX,
|
|
|
|
_SC_CLK_TCK,
|
|
|
|
_SC_NGROUPS_MAX,
|
|
|
|
_SC_OPEN_MAX,
|
|
|
|
_SC_STREAM_MAX,
|
|
|
|
_SC_TZNAME_MAX,
|
|
|
|
_SC_JOB_CONTROL,
|
|
|
|
_SC_SAVED_IDS,
|
|
|
|
_SC_REALTIME_SIGNALS,
|
|
|
|
_SC_PRIORITY_SCHEDULING,
|
|
|
|
_SC_TIMERS,
|
|
|
|
_SC_ASYNCHRONOUS_IO,
|
|
|
|
_SC_PRIORITIZED_IO,
|
|
|
|
_SC_SYNCHRONIZED_IO,
|
|
|
|
_SC_FSYNC,
|
|
|
|
_SC_MAPPED_FILES,
|
|
|
|
_SC_MEMLOCK,
|
|
|
|
_SC_MEMLOCK_RANGE,
|
|
|
|
_SC_MEMORY_PROTECTION,
|
|
|
|
_SC_MESSAGE_PASSING,
|
|
|
|
_SC_SEMAPHORES,
|
|
|
|
_SC_SHARED_MEMORY_OBJECTS,
|
|
|
|
_SC_AIO_LISTIO_MAX,
|
|
|
|
_SC_AIO_MAX,
|
|
|
|
_SC_AIO_PRIO_DELTA_MAX,
|
|
|
|
_SC_DELAYTIMER_MAX,
|
|
|
|
_SC_MQ_OPEN_MAX,
|
|
|
|
_SC_MQ_PRIO_MAX,
|
|
|
|
_SC_VERSION,
|
|
|
|
_SC_PAGESIZE,
|
|
|
|
|
|
_SC_RTSIG_MAX,
|
|
|
|
_SC_SEM_NSEMS_MAX,
|
|
|
|
_SC_SEM_VALUE_MAX,
|
|
|
|
_SC_SIGQUEUE_MAX,
|
|
|
|
_SC_TIMER_MAX,
|
|
|
|
|
|
|
|
|
|
_SC_BC_BASE_MAX,
|
|
|
|
_SC_BC_DIM_MAX,
|
|
|
|
_SC_BC_SCALE_MAX,
|
|
|
|
_SC_BC_STRING_MAX,
|
|
|
|
_SC_COLL_WEIGHTS_MAX,
|
|
|
|
_SC_EQUIV_CLASS_MAX,
|
|
|
|
_SC_EXPR_NEST_MAX,
|
|
|
|
_SC_LINE_MAX,
|
|
|
|
_SC_RE_DUP_MAX,
|
|
|
|
_SC_CHARCLASS_NAME_MAX,
|
|
|
|
|
|
_SC_2_VERSION,
|
|
|
|
_SC_2_C_BIND,
|
|
|
|
_SC_2_C_DEV,
|
|
|
|
_SC_2_FORT_DEV,
|
|
|
|
_SC_2_FORT_RUN,
|
|
|
|
_SC_2_SW_DEV,
|
|
|
|
_SC_2_LOCALEDEF,
|
|
|
|
|
|
_SC_PII,
|
|
|
|
_SC_PII_XTI,
|
|
|
|
_SC_PII_SOCKET,
|
|
|
|
_SC_PII_INTERNET,
|
|
|
|
_SC_PII_OSI,
|
|
|
|
_SC_POLL,
|
|
|
|
_SC_SELECT,
|
|
|
|
_SC_UIO_MAXIOV,
|
|
|
|
_SC_IOV_MAX = _SC_UIO_MAXIOV,
|
|
|
|
_SC_PII_INTERNET_STREAM,
|
|
|
|
_SC_PII_INTERNET_DGRAM,
|
|
|
|
_SC_PII_OSI_COTS,
|
|
|
|
_SC_PII_OSI_CLTS,
|
|
|
|
_SC_PII_OSI_M,
|
|
|
|
_SC_T_IOV_MAX,
|
|
|
|
|
|
|
|
_SC_THREADS,
|
|
|
|
_SC_THREAD_SAFE_FUNCTIONS,
|
|
|
|
_SC_GETGR_R_SIZE_MAX,
|
|
|
|
_SC_GETPW_R_SIZE_MAX,
|
|
|
|
_SC_LOGIN_NAME_MAX,
|
|
|
|
_SC_TTY_NAME_MAX,
|
|
|
|
_SC_THREAD_DESTRUCTOR_ITERATIONS,
|
|
|
|
_SC_THREAD_KEYS_MAX,
|
|
|
|
_SC_THREAD_STACK_MIN,
|
|
|
|
_SC_THREAD_THREADS_MAX,
|
|
|
|
_SC_THREAD_ATTR_STACKADDR,
|
|
|
|
_SC_THREAD_ATTR_STACKSIZE,
|
|
|
|
_SC_THREAD_PRIORITY_SCHEDULING,
|
|
|
|
_SC_THREAD_PRIO_INHERIT,
|
|
|
|
_SC_THREAD_PRIO_PROTECT,
|
|
|
|
_SC_THREAD_PROCESS_SHARED,
|
|
|
|
|
|
_SC_NPROCESSORS_CONF,
|
|
|
|
_SC_NPROCESSORS_ONLN,
|
|
|
|
_SC_PHYS_PAGES,
|
|
|
|
_SC_AVPHYS_PAGES,
|
|
|
|
_SC_ATEXIT_MAX,
|
|
|
|
_SC_PASS_MAX,
|
|
|
|
|
|
_SC_XOPEN_VERSION,
|
|
|
|
_SC_XOPEN_XCU_VERSION,
|
|
|
|
_SC_XOPEN_UNIX,
|
|
|
|
_SC_XOPEN_CRYPT,
|
|
|
|
_SC_XOPEN_ENH_I18N,
|
|
|
|
_SC_XOPEN_SHM,
|
|
|
|
|
|
_SC_2_CHAR_TERM,
|
|
|
|
_SC_2_C_VERSION,
|
|
|
|
_SC_2_UPE,
|
|
|
|
|
|
_SC_XOPEN_XPG2,
|
|
|
|
_SC_XOPEN_XPG3,
|
|
|
|
_SC_XOPEN_XPG4,
|
|
|
|
|
|
_SC_CHAR_BIT,
|
|
|
|
_SC_CHAR_MAX,
|
|
|
|
_SC_CHAR_MIN,
|
|
|
|
_SC_INT_MAX,
|
|
|
|
_SC_INT_MIN,
|
|
|
|
_SC_LONG_BIT,
|
|
|
|
_SC_WORD_BIT,
|
|
|
|
_SC_MB_LEN_MAX,
|
|
|
|
_SC_NZERO,
|
|
|
|
_SC_SSIZE_MAX,
|
|
|
|
_SC_SCHAR_MAX,
|
|
|
|
_SC_SCHAR_MIN,
|
|
|
|
_SC_SHRT_MAX,
|
|
|
|
_SC_SHRT_MIN,
|
|
|
|
_SC_UCHAR_MAX,
|
|
|
|
_SC_UINT_MAX,
|
|
|
|
_SC_ULONG_MAX,
|
|
|
|
_SC_USHRT_MAX,
|
|
|
|
|
|
_SC_NL_ARGMAX,
|
|
|
|
_SC_NL_LANGMAX,
|
|
|
|
_SC_NL_MSGMAX,
|
|
|
|
_SC_NL_NMAX,
|
|
|
|
_SC_NL_SETMAX,
|
|
|
|
_SC_NL_TEXTMAX,
|
|
|
|
|
|
_SC_XBS5_ILP32_OFF32,
|
|
|
|
_SC_XBS5_ILP32_OFFBIG,
|
|
|
|
_SC_XBS5_LP64_OFF64,
|
|
|
|
_SC_XBS5_LPBIG_OFFBIG,
|
|
|
|
|
|
_SC_XOPEN_LEGACY,
|
|
|
|
_SC_XOPEN_REALTIME,
|
|
|
|
_SC_XOPEN_REALTIME_THREADS,
|
|
|
|
|
|
_SC_ADVISORY_INFO,
|
|
|
|
_SC_BARRIERS,
|
|
|
|
_SC_BASE,
|
|
|
|
_SC_C_LANG_SUPPORT,
|
|
|
|
_SC_C_LANG_SUPPORT_R,
|
|
|
|
_SC_CLOCK_SELECTION,
|
|
|
|
_SC_CPUTIME,
|
|
|
|
_SC_THREAD_CPUTIME,
|
|
|
|
_SC_DEVICE_IO,
|
|
|
|
_SC_DEVICE_SPECIFIC,
|
|
|
|
_SC_DEVICE_SPECIFIC_R,
|
|
|
|
_SC_FD_MGMT,
|
|
|
|
_SC_FIFO,
|
|
|
|
_SC_PIPE,
|
|
|
|
_SC_FILE_ATTRIBUTES,
|
|
|
|
_SC_FILE_LOCKING,
|
|
|
|
_SC_FILE_SYSTEM,
|
|
|
|
_SC_MONOTONIC_CLOCK,
|
|
|
|
_SC_MULTI_PROCESS,
|
|
|
|
_SC_SINGLE_PROCESS,
|
|
|
|
_SC_NETWORKING,
|
|
|
|
_SC_READER_WRITER_LOCKS,
|
|
|
|
_SC_SPIN_LOCKS,
|
|
|
|
_SC_REGEXP,
|
|
|
|
_SC_REGEX_VERSION,
|
|
|
|
_SC_SHELL,
|
|
|
|
_SC_SIGNALS,
|
|
|
|
_SC_SPAWN,
|
|
|
|
_SC_SPORADIC_SERVER,
|
|
|
|
_SC_THREAD_SPORADIC_SERVER,
|
|
|
|
_SC_SYSTEM_DATABASE,
|
|
|
|
_SC_SYSTEM_DATABASE_R,
|
|
|
|
_SC_TIMEOUTS,
|
|
|
|
_SC_TYPED_MEMORY_OBJECTS,
|
|
|
|
_SC_USER_GROUPS,
|
|
|
|
_SC_USER_GROUPS_R,
|
|
|
|
_SC_2_PBS,
|
|
|
|
_SC_2_PBS_ACCOUNTING,
|
|
|
|
_SC_2_PBS_LOCATE,
|
|
|
|
_SC_2_PBS_MESSAGE,
|
|
|
|
_SC_2_PBS_TRACK,
|
|
|
|
_SC_SYMLOOP_MAX,
|
|
|
|
_SC_STREAMS,
|
|
|
|
_SC_2_PBS_CHECKPOINT,
|
|
|
|
|
|
_SC_V6_ILP32_OFF32,
|
|
|
|
_SC_V6_ILP32_OFFBIG,
|
|
|
|
_SC_V6_LP64_OFF64,
|
|
|
|
_SC_V6_LPBIG_OFFBIG,
|
|
|
|
|
|
_SC_HOST_NAME_MAX,
|
|
|
|
_SC_TRACE,
|
|
|
|
_SC_TRACE_EVENT_FILTER,
|
|
|
|
_SC_TRACE_INHERIT,
|
|
|
|
_SC_TRACE_LOG,
|
|
|
|
|
|
_SC_LEVEL1_ICACHE_SIZE,
|
|
|
|
_SC_LEVEL1_ICACHE_ASSOC,
|
|
|
|
_SC_LEVEL1_ICACHE_LINESIZE,
|
|
|
|
_SC_LEVEL1_DCACHE_SIZE,
|
|
|
|
_SC_LEVEL1_DCACHE_ASSOC,
|
|
|
|
_SC_LEVEL1_DCACHE_LINESIZE,
|
|
|
|
_SC_LEVEL2_CACHE_SIZE,
|
|
|
|
_SC_LEVEL2_CACHE_ASSOC,
|
|
|
|
_SC_LEVEL2_CACHE_LINESIZE,
|
|
|
|
_SC_LEVEL3_CACHE_SIZE,
|
|
|
|
_SC_LEVEL3_CACHE_ASSOC,
|
|
|
|
_SC_LEVEL3_CACHE_LINESIZE,
|
|
|
|
_SC_LEVEL4_CACHE_SIZE,
|
|
|
|
_SC_LEVEL4_CACHE_ASSOC,
|
|
|
|
_SC_LEVEL4_CACHE_LINESIZE,
|
|
|
|
|
|
|
|
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
|
|
|
|
_SC_RAW_SOCKETS,
|
|
|
|
|
|
_SC_V7_ILP32_OFF32,
|
|
|
|
_SC_V7_ILP32_OFFBIG,
|
|
|
|
_SC_V7_LP64_OFF64,
|
|
|
|
_SC_V7_LPBIG_OFFBIG,
|
|
|
|
|
|
_SC_SS_REPL_MAX,
|
|
|
|
|
|
_SC_TRACE_EVENT_NAME_MAX,
|
|
|
|
_SC_TRACE_NAME_MAX,
|
|
|
|
_SC_TRACE_SYS_MAX,
|
|
|
|
_SC_TRACE_USER_EVENT_MAX,
|
|
|
|
|
|
_SC_XOPEN_STREAMS,
|
|
|
|
|
|
_SC_THREAD_ROBUST_PRIO_INHERIT,
|
|
|
|
_SC_THREAD_ROBUST_PRIO_PROTECT
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
_CS_PATH,
|
|
|
|
|
|
_CS_V6_WIDTH_RESTRICTED_ENVS,
|
|
|
|
|
|
|
|
_CS_GNU_LIBC_VERSION,
|
|
|
|
_CS_GNU_LIBPTHREAD_VERSION,
|
|
|
|
|
|
_CS_V5_WIDTH_RESTRICTED_ENVS,
|
|
|
|
|
|
|
|
_CS_V7_WIDTH_RESTRICTED_ENVS,
|
|
|
|
|
|
|
|
_CS_LFS_CFLAGS = 1000,
|
|
|
|
_CS_LFS_LDFLAGS,
|
|
|
|
_CS_LFS_LIBS,
|
|
|
|
_CS_LFS_LINTFLAGS,
|
|
|
|
_CS_LFS64_CFLAGS,
|
|
|
|
_CS_LFS64_LDFLAGS,
|
|
|
|
_CS_LFS64_LIBS,
|
|
|
|
_CS_LFS64_LINTFLAGS,
|
|
|
|
|
|
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
|
|
|
|
_CS_XBS5_ILP32_OFF32_LDFLAGS,
|
|
|
|
_CS_XBS5_ILP32_OFF32_LIBS,
|
|
|
|
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
|
|
|
|
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
|
|
|
|
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
|
|
|
|
_CS_XBS5_ILP32_OFFBIG_LIBS,
|
|
|
|
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
|
|
|
|
_CS_XBS5_LP64_OFF64_CFLAGS,
|
|
|
|
_CS_XBS5_LP64_OFF64_LDFLAGS,
|
|
|
|
_CS_XBS5_LP64_OFF64_LIBS,
|
|
|
|
_CS_XBS5_LP64_OFF64_LINTFLAGS,
|
|
|
|
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
|
|
|
|
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
|
|
|
|
_CS_XBS5_LPBIG_OFFBIG_LIBS,
|
|
|
|
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
|
|
|
|
|
|
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFF32_LIBS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
|
|
|
|
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
|
|
|
|
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
|
|
|
|
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
|
|
|
|
_CS_POSIX_V6_LP64_OFF64_LIBS,
|
|
|
|
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
|
|
|
|
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
|
|
|
|
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
|
|
|
|
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
|
|
|
|
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
|
|
|
|
|
|
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFF32_LIBS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
|
|
|
|
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
|
|
|
|
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
|
|
|
|
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
|
|
|
|
_CS_POSIX_V7_LP64_OFF64_LIBS,
|
|
|
|
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
|
|
|
|
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
|
|
|
|
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
|
|
|
|
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
|
|
|
|
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
|
|
|
|
|
|
_CS_V6_ENV,
|
|
|
|
_CS_V7_ENV
|
|
|
|
};
|
|
# 610 "/usr/include/unistd.h" 2 3 4
|
|
|
|
|
|
extern long int pathconf (const char *__path, int __name)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern long int fpathconf (int __fd, int __name) throw ();
|
|
|
|
|
|
extern long int sysconf (int __name) throw ();
|
|
|
|
|
|
|
|
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
|
|
|
|
|
|
|
|
|
|
extern __pid_t getpid (void) throw ();
|
|
|
|
|
|
extern __pid_t getppid (void) throw ();
|
|
|
|
|
|
|
|
|
|
extern __pid_t getpgrp (void) throw ();
|
|
# 646 "/usr/include/unistd.h" 3 4
|
|
extern __pid_t __getpgid (__pid_t __pid) throw ();
|
|
|
|
extern __pid_t getpgid (__pid_t __pid) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
|
|
# 672 "/usr/include/unistd.h" 3 4
|
|
extern int setpgrp (void) throw ();
|
|
# 689 "/usr/include/unistd.h" 3 4
|
|
extern __pid_t setsid (void) throw ();
|
|
|
|
|
|
|
|
extern __pid_t getsid (__pid_t __pid) throw ();
|
|
|
|
|
|
|
|
extern __uid_t getuid (void) throw ();
|
|
|
|
|
|
extern __uid_t geteuid (void) throw ();
|
|
|
|
|
|
extern __gid_t getgid (void) throw ();
|
|
|
|
|
|
extern __gid_t getegid (void) throw ();
|
|
|
|
|
|
|
|
|
|
extern int getgroups (int __size, __gid_t __list[]) throw () ;
|
|
|
|
|
|
|
|
extern int group_member (__gid_t __gid) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int setuid (__uid_t __uid) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int seteuid (__uid_t __uid) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int setgid (__gid_t __gid) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int setegid (__gid_t __gid) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
|
|
throw ();
|
|
|
|
|
|
|
|
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
|
|
throw ();
|
|
|
|
|
|
|
|
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
|
|
throw () ;
|
|
|
|
|
|
|
|
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
|
|
throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __pid_t fork (void) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __pid_t vfork (void) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern char *ttyname (int __fd) throw ();
|
|
|
|
|
|
|
|
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
|
|
throw () __attribute__ ((__nonnull__ (2))) ;
|
|
|
|
|
|
|
|
extern int isatty (int __fd) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int ttyslot (void) throw ();
|
|
|
|
|
|
|
|
|
|
extern int link (const char *__from, const char *__to)
|
|
throw () __attribute__ ((__nonnull__ (1, 2))) ;
|
|
|
|
|
|
|
|
|
|
extern int linkat (int __fromfd, const char *__from, int __tofd,
|
|
const char *__to, int __flags)
|
|
throw () __attribute__ ((__nonnull__ (2, 4))) ;
|
|
|
|
|
|
|
|
|
|
extern int symlink (const char *__from, const char *__to)
|
|
throw () __attribute__ ((__nonnull__ (1, 2))) ;
|
|
|
|
|
|
|
|
|
|
extern ssize_t readlink (const char *__restrict __path,
|
|
char *__restrict __buf, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (1, 2))) ;
|
|
|
|
|
|
|
|
|
|
extern int symlinkat (const char *__from, int __tofd,
|
|
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
|
|
|
|
|
|
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
|
|
char *__restrict __buf, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (2, 3))) ;
|
|
|
|
|
|
|
|
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int unlinkat (int __fd, const char *__name, int __flag)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern __pid_t tcgetpgrp (int __fd) throw ();
|
|
|
|
|
|
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *getlogin (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
|
|
# 893 "/usr/include/unistd.h" 3 4
|
|
# 1 "/usr/include/getopt.h" 1 3 4
|
|
# 49 "/usr/include/getopt.h" 3 4
|
|
extern "C" {
|
|
# 58 "/usr/include/getopt.h" 3 4
|
|
extern char *optarg;
|
|
# 72 "/usr/include/getopt.h" 3 4
|
|
extern int optind;
|
|
|
|
|
|
|
|
|
|
extern int opterr;
|
|
|
|
|
|
|
|
extern int optopt;
|
|
# 151 "/usr/include/getopt.h" 3 4
|
|
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
|
|
throw ();
|
|
# 186 "/usr/include/getopt.h" 3 4
|
|
}
|
|
# 894 "/usr/include/unistd.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sethostname (const char *__name, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
extern int sethostid (long int __id) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int getdomainname (char *__name, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
extern int setdomainname (const char *__name, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int vhangup (void) throw ();
|
|
|
|
|
|
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int profil (unsigned short int *__sample_buffer, size_t __size,
|
|
size_t __offset, unsigned int __scale)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int acct (const char *__name) throw ();
|
|
|
|
|
|
|
|
extern char *getusershell (void) throw ();
|
|
extern void endusershell (void) throw ();
|
|
extern void setusershell (void) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int daemon (int __nochdir, int __noclose) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fsync (int __fd);
|
|
|
|
|
|
|
|
|
|
|
|
extern int syncfs (int __fd) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern long int gethostid (void);
|
|
|
|
|
|
extern void sync (void) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int getpagesize (void) throw () __attribute__ ((__const__));
|
|
|
|
|
|
|
|
|
|
extern int getdtablesize (void) throw ();
|
|
# 1015 "/usr/include/unistd.h" 3 4
|
|
extern int truncate (const char *__file, __off_t __length)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
# 1027 "/usr/include/unistd.h" 3 4
|
|
extern int truncate64 (const char *__file, __off64_t __length)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
# 1038 "/usr/include/unistd.h" 3 4
|
|
extern int ftruncate (int __fd, __off_t __length) throw () ;
|
|
# 1048 "/usr/include/unistd.h" 3 4
|
|
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
|
|
# 1059 "/usr/include/unistd.h" 3 4
|
|
extern int brk (void *__addr) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern void *sbrk (intptr_t __delta) throw ();
|
|
# 1080 "/usr/include/unistd.h" 3 4
|
|
extern long int syscall (long int __sysno, ...) throw ();
|
|
# 1103 "/usr/include/unistd.h" 3 4
|
|
extern int lockf (int __fd, int __cmd, __off_t __len) ;
|
|
# 1113 "/usr/include/unistd.h" 3 4
|
|
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
|
|
# 1134 "/usr/include/unistd.h" 3 4
|
|
extern int fdatasync (int __fildes);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *crypt (const char *__key, const char *__salt)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void swab (const void *__restrict __from, void *__restrict __to,
|
|
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
# 1172 "/usr/include/unistd.h" 3 4
|
|
}
|
|
# 16 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/sys/time.h" 1 3 4
|
|
# 28 "/usr/include/sys/time.h" 3 4
|
|
# 1 "/usr/include/bits/time.h" 1 3 4
|
|
# 29 "/usr/include/sys/time.h" 2 3 4
|
|
|
|
# 1 "/usr/include/sys/select.h" 1 3 4
|
|
# 30 "/usr/include/sys/select.h" 3 4
|
|
# 1 "/usr/include/bits/select.h" 1 3 4
|
|
# 22 "/usr/include/bits/select.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 23 "/usr/include/bits/select.h" 2 3 4
|
|
# 31 "/usr/include/sys/select.h" 2 3 4
|
|
|
|
|
|
# 1 "/usr/include/bits/sigset.h" 1 3 4
|
|
# 23 "/usr/include/bits/sigset.h" 3 4
|
|
typedef int __sig_atomic_t;
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
|
|
} __sigset_t;
|
|
# 34 "/usr/include/sys/select.h" 2 3 4
|
|
|
|
|
|
|
|
typedef __sigset_t sigset_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/time.h" 1 3 4
|
|
# 46 "/usr/include/sys/select.h" 2 3 4
|
|
|
|
|
|
typedef __suseconds_t suseconds_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef long int __fd_mask;
|
|
# 64 "/usr/include/sys/select.h" 3 4
|
|
typedef struct
|
|
{
|
|
|
|
|
|
|
|
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
|
|
|
|
|
|
|
|
|
|
|
|
} fd_set;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __fd_mask fd_mask;
|
|
# 96 "/usr/include/sys/select.h" 3 4
|
|
extern "C" {
|
|
# 106 "/usr/include/sys/select.h" 3 4
|
|
extern int select (int __nfds, fd_set *__restrict __readfds,
|
|
fd_set *__restrict __writefds,
|
|
fd_set *__restrict __exceptfds,
|
|
struct timeval *__restrict __timeout);
|
|
# 118 "/usr/include/sys/select.h" 3 4
|
|
extern int pselect (int __nfds, fd_set *__restrict __readfds,
|
|
fd_set *__restrict __writefds,
|
|
fd_set *__restrict __exceptfds,
|
|
const struct timespec *__restrict __timeout,
|
|
const __sigset_t *__restrict __sigmask);
|
|
# 131 "/usr/include/sys/select.h" 3 4
|
|
}
|
|
# 31 "/usr/include/sys/time.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" {
|
|
# 56 "/usr/include/sys/time.h" 3 4
|
|
struct timezone
|
|
{
|
|
int tz_minuteswest;
|
|
int tz_dsttime;
|
|
};
|
|
|
|
typedef struct timezone *__restrict __timezone_ptr_t;
|
|
# 72 "/usr/include/sys/time.h" 3 4
|
|
extern int gettimeofday (struct timeval *__restrict __tv,
|
|
__timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
extern int settimeofday (const struct timeval *__tv,
|
|
const struct timezone *__tz)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int adjtime (const struct timeval *__delta,
|
|
struct timeval *__olddelta) throw ();
|
|
|
|
|
|
|
|
|
|
enum __itimer_which
|
|
{
|
|
|
|
ITIMER_REAL = 0,
|
|
|
|
|
|
ITIMER_VIRTUAL = 1,
|
|
|
|
|
|
|
|
ITIMER_PROF = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
struct itimerval
|
|
{
|
|
|
|
struct timeval it_interval;
|
|
|
|
struct timeval it_value;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef int __itimer_which_t;
|
|
|
|
|
|
|
|
|
|
extern int getitimer (__itimer_which_t __which,
|
|
struct itimerval *__value) throw ();
|
|
|
|
|
|
|
|
|
|
extern int setitimer (__itimer_which_t __which,
|
|
const struct itimerval *__restrict __new,
|
|
struct itimerval *__restrict __old) throw ();
|
|
|
|
|
|
|
|
|
|
extern int utimes (const char *__file, const struct timeval __tvp[2])
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int lutimes (const char *__file, const struct timeval __tvp[2])
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int futimesat (int __fd, const char *__file,
|
|
const struct timeval __tvp[2]) throw ();
|
|
# 190 "/usr/include/sys/time.h" 3 4
|
|
}
|
|
# 17 "include/CTypedef.h" 2
|
|
# 1 "/usr/include/arpa/inet.h" 1 3 4
|
|
# 22 "/usr/include/arpa/inet.h" 3 4
|
|
# 1 "/usr/include/netinet/in.h" 1 3 4
|
|
# 23 "/usr/include/netinet/in.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdint.h" 1 3 4
|
|
# 9 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdint.h" 3 4
|
|
# 1 "/usr/include/stdint.h" 1 3 4
|
|
# 27 "/usr/include/stdint.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 28 "/usr/include/stdint.h" 2 3 4
|
|
# 36 "/usr/include/stdint.h" 3 4
|
|
typedef signed char int8_t;
|
|
typedef short int int16_t;
|
|
typedef int int32_t;
|
|
|
|
typedef long int int64_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef unsigned char uint8_t;
|
|
typedef unsigned short int uint16_t;
|
|
|
|
typedef unsigned int uint32_t;
|
|
|
|
|
|
|
|
typedef unsigned long int uint64_t;
|
|
# 65 "/usr/include/stdint.h" 3 4
|
|
typedef signed char int_least8_t;
|
|
typedef short int int_least16_t;
|
|
typedef int int_least32_t;
|
|
|
|
typedef long int int_least64_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef unsigned char uint_least8_t;
|
|
typedef unsigned short int uint_least16_t;
|
|
typedef unsigned int uint_least32_t;
|
|
|
|
typedef unsigned long int uint_least64_t;
|
|
# 90 "/usr/include/stdint.h" 3 4
|
|
typedef signed char int_fast8_t;
|
|
|
|
typedef long int int_fast16_t;
|
|
typedef long int int_fast32_t;
|
|
typedef long int int_fast64_t;
|
|
# 103 "/usr/include/stdint.h" 3 4
|
|
typedef unsigned char uint_fast8_t;
|
|
|
|
typedef unsigned long int uint_fast16_t;
|
|
typedef unsigned long int uint_fast32_t;
|
|
typedef unsigned long int uint_fast64_t;
|
|
# 122 "/usr/include/stdint.h" 3 4
|
|
typedef unsigned long int uintptr_t;
|
|
# 134 "/usr/include/stdint.h" 3 4
|
|
typedef long int intmax_t;
|
|
typedef unsigned long int uintmax_t;
|
|
# 10 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdint.h" 2 3 4
|
|
# 24 "/usr/include/netinet/in.h" 2 3 4
|
|
# 1 "/usr/include/sys/socket.h" 1 3 4
|
|
# 25 "/usr/include/sys/socket.h" 3 4
|
|
extern "C" {
|
|
|
|
# 1 "/usr/include/sys/uio.h" 1 3 4
|
|
# 24 "/usr/include/sys/uio.h" 3 4
|
|
# 1 "/usr/include/sys/types.h" 1 3 4
|
|
# 27 "/usr/include/sys/types.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
|
|
typedef __u_char u_char;
|
|
typedef __u_short u_short;
|
|
typedef __u_int u_int;
|
|
typedef __u_long u_long;
|
|
typedef __quad_t quad_t;
|
|
typedef __u_quad_t u_quad_t;
|
|
typedef __fsid_t fsid_t;
|
|
|
|
|
|
|
|
|
|
typedef __loff_t loff_t;
|
|
|
|
|
|
|
|
typedef __ino_t ino_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __ino64_t ino64_t;
|
|
|
|
|
|
|
|
|
|
typedef __dev_t dev_t;
|
|
# 70 "/usr/include/sys/types.h" 3 4
|
|
typedef __mode_t mode_t;
|
|
|
|
|
|
|
|
|
|
typedef __nlink_t nlink_t;
|
|
# 104 "/usr/include/sys/types.h" 3 4
|
|
typedef __id_t id_t;
|
|
# 115 "/usr/include/sys/types.h" 3 4
|
|
typedef __daddr_t daddr_t;
|
|
typedef __caddr_t caddr_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef __key_t key_t;
|
|
# 146 "/usr/include/sys/types.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 147 "/usr/include/sys/types.h" 2 3 4
|
|
|
|
|
|
|
|
typedef unsigned long int ulong;
|
|
typedef unsigned short int ushort;
|
|
typedef unsigned int uint;
|
|
# 200 "/usr/include/sys/types.h" 3 4
|
|
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
|
|
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
|
|
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
|
|
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
|
|
|
|
typedef int register_t __attribute__ ((__mode__ (__word__)));
|
|
# 222 "/usr/include/sys/types.h" 3 4
|
|
# 1 "/usr/include/sys/sysmacros.h" 1 3 4
|
|
# 29 "/usr/include/sys/sysmacros.h" 3 4
|
|
extern "C" {
|
|
|
|
__extension__
|
|
extern unsigned int gnu_dev_major (unsigned long long int __dev)
|
|
throw () __attribute__ ((__const__));
|
|
__extension__
|
|
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
|
|
throw () __attribute__ ((__const__));
|
|
__extension__
|
|
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
|
|
unsigned int __minor)
|
|
throw () __attribute__ ((__const__));
|
|
# 63 "/usr/include/sys/sysmacros.h" 3 4
|
|
}
|
|
# 223 "/usr/include/sys/types.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
typedef __blksize_t blksize_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __blkcnt_t blkcnt_t;
|
|
|
|
|
|
|
|
typedef __fsblkcnt_t fsblkcnt_t;
|
|
|
|
|
|
|
|
typedef __fsfilcnt_t fsfilcnt_t;
|
|
# 262 "/usr/include/sys/types.h" 3 4
|
|
typedef __blkcnt64_t blkcnt64_t;
|
|
typedef __fsblkcnt64_t fsblkcnt64_t;
|
|
typedef __fsfilcnt64_t fsfilcnt64_t;
|
|
# 273 "/usr/include/sys/types.h" 3 4
|
|
}
|
|
# 25 "/usr/include/sys/uio.h" 2 3 4
|
|
|
|
extern "C" {
|
|
|
|
|
|
# 1 "/usr/include/bits/uio.h" 1 3 4
|
|
# 43 "/usr/include/bits/uio.h" 3 4
|
|
struct iovec
|
|
{
|
|
void *iov_base;
|
|
size_t iov_len;
|
|
};
|
|
# 56 "/usr/include/bits/uio.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
|
|
unsigned long int __liovcnt,
|
|
const struct iovec *__rvec,
|
|
unsigned long int __riovcnt,
|
|
unsigned long int __flags)
|
|
throw ();
|
|
|
|
|
|
extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
|
|
unsigned long int __liovcnt,
|
|
const struct iovec *__rvec,
|
|
unsigned long int __riovcnt,
|
|
unsigned long int __flags)
|
|
throw ();
|
|
|
|
}
|
|
# 30 "/usr/include/sys/uio.h" 2 3 4
|
|
# 40 "/usr/include/sys/uio.h" 3 4
|
|
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
|
|
;
|
|
# 51 "/usr/include/sys/uio.h" 3 4
|
|
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
|
|
;
|
|
# 66 "/usr/include/sys/uio.h" 3 4
|
|
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
|
|
__off_t __offset) ;
|
|
# 78 "/usr/include/sys/uio.h" 3 4
|
|
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
|
|
__off_t __offset) ;
|
|
# 104 "/usr/include/sys/uio.h" 3 4
|
|
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
|
|
__off64_t __offset) ;
|
|
# 116 "/usr/include/sys/uio.h" 3 4
|
|
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
|
|
__off64_t __offset) ;
|
|
|
|
|
|
|
|
}
|
|
# 28 "/usr/include/sys/socket.h" 2 3 4
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 30 "/usr/include/sys/socket.h" 2 3 4
|
|
|
|
|
|
# 1 "/usr/include/bits/sigset.h" 1 3 4
|
|
# 33 "/usr/include/sys/socket.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/socket.h" 1 3 4
|
|
# 28 "/usr/include/bits/socket.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 29 "/usr/include/bits/socket.h" 2 3 4
|
|
# 39 "/usr/include/bits/socket.h" 3 4
|
|
# 1 "/usr/include/bits/socket_type.h" 1 3 4
|
|
# 24 "/usr/include/bits/socket_type.h" 3 4
|
|
enum __socket_type
|
|
{
|
|
SOCK_STREAM = 1,
|
|
|
|
|
|
SOCK_DGRAM = 2,
|
|
|
|
|
|
SOCK_RAW = 3,
|
|
|
|
SOCK_RDM = 4,
|
|
|
|
SOCK_SEQPACKET = 5,
|
|
|
|
|
|
SOCK_DCCP = 6,
|
|
|
|
SOCK_PACKET = 10,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SOCK_CLOEXEC = 02000000,
|
|
|
|
|
|
SOCK_NONBLOCK = 00004000
|
|
|
|
|
|
};
|
|
# 40 "/usr/include/bits/socket.h" 2 3 4
|
|
# 151 "/usr/include/bits/socket.h" 3 4
|
|
# 1 "/usr/include/bits/sockaddr.h" 1 3 4
|
|
# 28 "/usr/include/bits/sockaddr.h" 3 4
|
|
typedef unsigned short int sa_family_t;
|
|
# 152 "/usr/include/bits/socket.h" 2 3 4
|
|
|
|
|
|
struct sockaddr
|
|
{
|
|
sa_family_t sa_family;
|
|
char sa_data[14];
|
|
};
|
|
# 167 "/usr/include/bits/socket.h" 3 4
|
|
struct sockaddr_storage
|
|
{
|
|
sa_family_t ss_family;
|
|
char __ss_padding[(128 - (sizeof (unsigned short int)) - sizeof (unsigned long int))];
|
|
unsigned long int __ss_align;
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
MSG_OOB = 0x01,
|
|
|
|
MSG_PEEK = 0x02,
|
|
|
|
MSG_DONTROUTE = 0x04,
|
|
|
|
|
|
|
|
MSG_TRYHARD = MSG_DONTROUTE,
|
|
|
|
|
|
MSG_CTRUNC = 0x08,
|
|
|
|
MSG_PROXY = 0x10,
|
|
|
|
MSG_TRUNC = 0x20,
|
|
|
|
MSG_DONTWAIT = 0x40,
|
|
|
|
MSG_EOR = 0x80,
|
|
|
|
MSG_WAITALL = 0x100,
|
|
|
|
MSG_FIN = 0x200,
|
|
|
|
MSG_SYN = 0x400,
|
|
|
|
MSG_CONFIRM = 0x800,
|
|
|
|
MSG_RST = 0x1000,
|
|
|
|
MSG_ERRQUEUE = 0x2000,
|
|
|
|
MSG_NOSIGNAL = 0x4000,
|
|
|
|
MSG_MORE = 0x8000,
|
|
|
|
MSG_WAITFORONE = 0x10000,
|
|
|
|
MSG_FASTOPEN = 0x20000000,
|
|
|
|
|
|
MSG_CMSG_CLOEXEC = 0x40000000
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct msghdr
|
|
{
|
|
void *msg_name;
|
|
socklen_t msg_namelen;
|
|
|
|
struct iovec *msg_iov;
|
|
size_t msg_iovlen;
|
|
|
|
void *msg_control;
|
|
size_t msg_controllen;
|
|
|
|
|
|
|
|
|
|
int msg_flags;
|
|
};
|
|
|
|
|
|
struct cmsghdr
|
|
{
|
|
size_t cmsg_len;
|
|
|
|
|
|
|
|
|
|
int cmsg_level;
|
|
int cmsg_type;
|
|
|
|
__extension__ unsigned char __cmsg_data [];
|
|
|
|
};
|
|
# 277 "/usr/include/bits/socket.h" 3 4
|
|
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
|
|
struct cmsghdr *__cmsg) throw ();
|
|
# 304 "/usr/include/bits/socket.h" 3 4
|
|
enum
|
|
{
|
|
SCM_RIGHTS = 0x01
|
|
|
|
|
|
, SCM_CREDENTIALS = 0x02
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ucred
|
|
{
|
|
pid_t pid;
|
|
uid_t uid;
|
|
gid_t gid;
|
|
};
|
|
# 350 "/usr/include/bits/socket.h" 3 4
|
|
# 1 "/usr/include/asm/socket.h" 1 3 4
|
|
# 1 "/usr/include/asm-generic/socket.h" 1 3 4
|
|
|
|
|
|
|
|
# 1 "/usr/include/asm/sockios.h" 1 3 4
|
|
# 1 "/usr/include/asm-generic/sockios.h" 1 3 4
|
|
# 1 "/usr/include/asm/sockios.h" 2 3 4
|
|
# 5 "/usr/include/asm-generic/socket.h" 2 3 4
|
|
# 1 "/usr/include/asm/socket.h" 2 3 4
|
|
# 351 "/usr/include/bits/socket.h" 2 3 4
|
|
# 384 "/usr/include/bits/socket.h" 3 4
|
|
struct linger
|
|
{
|
|
int l_onoff;
|
|
int l_linger;
|
|
};
|
|
# 40 "/usr/include/sys/socket.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
struct osockaddr
|
|
{
|
|
unsigned short int sa_family;
|
|
unsigned char sa_data[14];
|
|
};
|
|
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
SHUT_RD = 0,
|
|
|
|
SHUT_WR,
|
|
|
|
SHUT_RDWR
|
|
|
|
};
|
|
# 102 "/usr/include/sys/socket.h" 3 4
|
|
struct mmsghdr
|
|
{
|
|
struct msghdr msg_hdr;
|
|
unsigned int msg_len;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int socket (int __domain, int __type, int __protocol) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int socketpair (int __domain, int __type, int __protocol,
|
|
int __fds[2]) throw ();
|
|
|
|
|
|
extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
|
|
throw ();
|
|
|
|
|
|
extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
|
|
socklen_t *__restrict __len) throw ();
|
|
# 138 "/usr/include/sys/socket.h" 3 4
|
|
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
|
|
|
|
|
|
|
|
extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
|
|
socklen_t *__restrict __len) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
|
|
int __flags, const struct sockaddr * __addr,
|
|
socklen_t __addr_len);
|
|
# 175 "/usr/include/sys/socket.h" 3 4
|
|
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
|
|
int __flags, struct sockaddr *__restrict __addr,
|
|
socklen_t *__restrict __addr_len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
|
|
int __flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
|
|
unsigned int __vlen, int __flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
|
|
unsigned int __vlen, int __flags,
|
|
const struct timespec *__tmo);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int getsockopt (int __fd, int __level, int __optname,
|
|
void *__restrict __optval,
|
|
socklen_t *__restrict __optlen) throw ();
|
|
|
|
|
|
|
|
|
|
extern int setsockopt (int __fd, int __level, int __optname,
|
|
const void *__optval, socklen_t __optlen) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int listen (int __fd, int __n) throw ();
|
|
# 244 "/usr/include/sys/socket.h" 3 4
|
|
extern int accept (int __fd, struct sockaddr *__restrict __addr,
|
|
socklen_t *__restrict __addr_len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
|
|
socklen_t *__restrict __addr_len, int __flags);
|
|
# 262 "/usr/include/sys/socket.h" 3 4
|
|
extern int shutdown (int __fd, int __how) throw ();
|
|
|
|
|
|
|
|
|
|
extern int sockatmark (int __fd) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int isfdtype (int __fd, int __fdtype) throw ();
|
|
# 284 "/usr/include/sys/socket.h" 3 4
|
|
}
|
|
# 25 "/usr/include/netinet/in.h" 2 3 4
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
typedef uint32_t in_addr_t;
|
|
struct in_addr
|
|
{
|
|
in_addr_t s_addr;
|
|
};
|
|
|
|
|
|
# 1 "/usr/include/bits/in.h" 1 3 4
|
|
# 148 "/usr/include/bits/in.h" 3 4
|
|
struct ip_opts
|
|
{
|
|
struct in_addr ip_dst;
|
|
char ip_opts[40];
|
|
};
|
|
|
|
|
|
struct ip_mreqn
|
|
{
|
|
struct in_addr imr_multiaddr;
|
|
struct in_addr imr_address;
|
|
int imr_ifindex;
|
|
};
|
|
|
|
|
|
struct in_pktinfo
|
|
{
|
|
int ipi_ifindex;
|
|
struct in_addr ipi_spec_dst;
|
|
struct in_addr ipi_addr;
|
|
};
|
|
# 39 "/usr/include/netinet/in.h" 2 3 4
|
|
|
|
|
|
enum
|
|
{
|
|
IPPROTO_IP = 0,
|
|
|
|
IPPROTO_ICMP = 1,
|
|
|
|
IPPROTO_IGMP = 2,
|
|
|
|
IPPROTO_IPIP = 4,
|
|
|
|
IPPROTO_TCP = 6,
|
|
|
|
IPPROTO_EGP = 8,
|
|
|
|
IPPROTO_PUP = 12,
|
|
|
|
IPPROTO_UDP = 17,
|
|
|
|
IPPROTO_IDP = 22,
|
|
|
|
IPPROTO_TP = 29,
|
|
|
|
IPPROTO_DCCP = 33,
|
|
|
|
IPPROTO_IPV6 = 41,
|
|
|
|
IPPROTO_RSVP = 46,
|
|
|
|
IPPROTO_GRE = 47,
|
|
|
|
IPPROTO_ESP = 50,
|
|
|
|
IPPROTO_AH = 51,
|
|
|
|
IPPROTO_MTP = 92,
|
|
|
|
IPPROTO_BEETPH = 94,
|
|
|
|
IPPROTO_ENCAP = 98,
|
|
|
|
IPPROTO_PIM = 103,
|
|
|
|
IPPROTO_COMP = 108,
|
|
|
|
IPPROTO_SCTP = 132,
|
|
|
|
IPPROTO_UDPLITE = 136,
|
|
|
|
IPPROTO_MPLS = 137,
|
|
|
|
IPPROTO_RAW = 255,
|
|
|
|
IPPROTO_MAX
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
IPPROTO_HOPOPTS = 0,
|
|
|
|
IPPROTO_ROUTING = 43,
|
|
|
|
IPPROTO_FRAGMENT = 44,
|
|
|
|
IPPROTO_ICMPV6 = 58,
|
|
|
|
IPPROTO_NONE = 59,
|
|
|
|
IPPROTO_DSTOPTS = 60,
|
|
|
|
IPPROTO_MH = 135
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef uint16_t in_port_t;
|
|
|
|
|
|
enum
|
|
{
|
|
IPPORT_ECHO = 7,
|
|
IPPORT_DISCARD = 9,
|
|
IPPORT_SYSTAT = 11,
|
|
IPPORT_DAYTIME = 13,
|
|
IPPORT_NETSTAT = 15,
|
|
IPPORT_FTP = 21,
|
|
IPPORT_TELNET = 23,
|
|
IPPORT_SMTP = 25,
|
|
IPPORT_TIMESERVER = 37,
|
|
IPPORT_NAMESERVER = 42,
|
|
IPPORT_WHOIS = 43,
|
|
IPPORT_MTP = 57,
|
|
|
|
IPPORT_TFTP = 69,
|
|
IPPORT_RJE = 77,
|
|
IPPORT_FINGER = 79,
|
|
IPPORT_TTYLINK = 87,
|
|
IPPORT_SUPDUP = 95,
|
|
|
|
|
|
IPPORT_EXECSERVER = 512,
|
|
IPPORT_LOGINSERVER = 513,
|
|
IPPORT_CMDSERVER = 514,
|
|
IPPORT_EFSSERVER = 520,
|
|
|
|
|
|
IPPORT_BIFFUDP = 512,
|
|
IPPORT_WHOSERVER = 513,
|
|
IPPORT_ROUTESERVER = 520,
|
|
|
|
|
|
IPPORT_RESERVED = 1024,
|
|
|
|
|
|
IPPORT_USERRESERVED = 5000
|
|
};
|
|
# 212 "/usr/include/netinet/in.h" 3 4
|
|
struct in6_addr
|
|
{
|
|
union
|
|
{
|
|
uint8_t __u6_addr8[16];
|
|
|
|
uint16_t __u6_addr16[8];
|
|
uint32_t __u6_addr32[4];
|
|
|
|
} __in6_u;
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
extern const struct in6_addr in6addr_any;
|
|
extern const struct in6_addr in6addr_loopback;
|
|
# 240 "/usr/include/netinet/in.h" 3 4
|
|
struct sockaddr_in
|
|
{
|
|
sa_family_t sin_family;
|
|
in_port_t sin_port;
|
|
struct in_addr sin_addr;
|
|
|
|
|
|
unsigned char sin_zero[sizeof (struct sockaddr) -
|
|
(sizeof (unsigned short int)) -
|
|
sizeof (in_port_t) -
|
|
sizeof (struct in_addr)];
|
|
};
|
|
|
|
|
|
|
|
struct sockaddr_in6
|
|
{
|
|
sa_family_t sin6_family;
|
|
in_port_t sin6_port;
|
|
uint32_t sin6_flowinfo;
|
|
struct in6_addr sin6_addr;
|
|
uint32_t sin6_scope_id;
|
|
};
|
|
|
|
|
|
|
|
|
|
struct ip_mreq
|
|
{
|
|
|
|
struct in_addr imr_multiaddr;
|
|
|
|
|
|
struct in_addr imr_interface;
|
|
};
|
|
|
|
struct ip_mreq_source
|
|
{
|
|
|
|
struct in_addr imr_multiaddr;
|
|
|
|
|
|
struct in_addr imr_interface;
|
|
|
|
|
|
struct in_addr imr_sourceaddr;
|
|
};
|
|
|
|
|
|
|
|
|
|
struct ipv6_mreq
|
|
{
|
|
|
|
struct in6_addr ipv6mr_multiaddr;
|
|
|
|
|
|
unsigned int ipv6mr_interface;
|
|
};
|
|
|
|
|
|
|
|
|
|
struct group_req
|
|
{
|
|
|
|
uint32_t gr_interface;
|
|
|
|
|
|
struct sockaddr_storage gr_group;
|
|
};
|
|
|
|
struct group_source_req
|
|
{
|
|
|
|
uint32_t gsr_interface;
|
|
|
|
|
|
struct sockaddr_storage gsr_group;
|
|
|
|
|
|
struct sockaddr_storage gsr_source;
|
|
};
|
|
|
|
|
|
|
|
struct ip_msfilter
|
|
{
|
|
|
|
struct in_addr imsf_multiaddr;
|
|
|
|
|
|
struct in_addr imsf_interface;
|
|
|
|
|
|
uint32_t imsf_fmode;
|
|
|
|
|
|
uint32_t imsf_numsrc;
|
|
|
|
struct in_addr imsf_slist[1];
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct group_filter
|
|
{
|
|
|
|
uint32_t gf_interface;
|
|
|
|
|
|
struct sockaddr_storage gf_group;
|
|
|
|
|
|
uint32_t gf_fmode;
|
|
|
|
|
|
uint32_t gf_numsrc;
|
|
|
|
struct sockaddr_storage gf_slist[1];
|
|
};
|
|
# 377 "/usr/include/netinet/in.h" 3 4
|
|
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
|
|
extern uint16_t ntohs (uint16_t __netshort)
|
|
throw () __attribute__ ((__const__));
|
|
extern uint32_t htonl (uint32_t __hostlong)
|
|
throw () __attribute__ ((__const__));
|
|
extern uint16_t htons (uint16_t __hostshort)
|
|
throw () __attribute__ ((__const__));
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/byteswap.h" 1 3 4
|
|
# 389 "/usr/include/netinet/in.h" 2 3 4
|
|
# 504 "/usr/include/netinet/in.h" 3 4
|
|
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
|
|
|
|
|
|
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
|
|
throw ();
|
|
# 534 "/usr/include/netinet/in.h" 3 4
|
|
struct cmsghdr;
|
|
|
|
|
|
|
|
struct in6_pktinfo
|
|
{
|
|
struct in6_addr ipi6_addr;
|
|
unsigned int ipi6_ifindex;
|
|
};
|
|
|
|
|
|
struct ip6_mtuinfo
|
|
{
|
|
struct sockaddr_in6 ip6m_addr;
|
|
uint32_t ip6m_mtu;
|
|
};
|
|
|
|
|
|
|
|
extern int inet6_option_space (int __nbytes)
|
|
throw () __attribute__ ((__deprecated__));
|
|
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
|
|
int __type) throw () __attribute__ ((__deprecated__));
|
|
extern int inet6_option_append (struct cmsghdr *__cmsg,
|
|
const uint8_t *__typep, int __multx,
|
|
int __plusy) throw () __attribute__ ((__deprecated__));
|
|
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
|
|
int __multx, int __plusy)
|
|
throw () __attribute__ ((__deprecated__));
|
|
extern int inet6_option_next (const struct cmsghdr *__cmsg,
|
|
uint8_t **__tptrp)
|
|
throw () __attribute__ ((__deprecated__));
|
|
extern int inet6_option_find (const struct cmsghdr *__cmsg,
|
|
uint8_t **__tptrp, int __type)
|
|
throw () __attribute__ ((__deprecated__));
|
|
|
|
|
|
|
|
extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
|
|
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
|
|
uint8_t __type, socklen_t __len, uint8_t __align,
|
|
void **__databufp) throw ();
|
|
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
|
|
throw ();
|
|
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
|
|
socklen_t __vallen) throw ();
|
|
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
|
|
uint8_t *__typep, socklen_t *__lenp,
|
|
void **__databufp) throw ();
|
|
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
|
|
uint8_t __type, socklen_t *__lenp,
|
|
void **__databufp) throw ();
|
|
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
|
|
socklen_t __vallen) throw ();
|
|
|
|
|
|
|
|
extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
|
|
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
|
|
int __segments) throw ();
|
|
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
|
|
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
|
|
extern int inet6_rth_segments (const void *__bp) throw ();
|
|
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
|
|
struct in_addr __group, uint32_t *__fmode,
|
|
uint32_t *__numsrc, struct in_addr *__slist)
|
|
throw ();
|
|
|
|
|
|
extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
|
|
struct in_addr __group, uint32_t __fmode,
|
|
uint32_t __numsrc,
|
|
const struct in_addr *__slist)
|
|
throw ();
|
|
|
|
|
|
|
|
extern int getsourcefilter (int __s, uint32_t __interface_addr,
|
|
const struct sockaddr *__group,
|
|
socklen_t __grouplen, uint32_t *__fmode,
|
|
uint32_t *__numsrc,
|
|
struct sockaddr_storage *__slist) throw ();
|
|
|
|
|
|
extern int setsourcefilter (int __s, uint32_t __interface_addr,
|
|
const struct sockaddr *__group,
|
|
socklen_t __grouplen, uint32_t __fmode,
|
|
uint32_t __numsrc,
|
|
const struct sockaddr_storage *__slist) throw ();
|
|
|
|
|
|
}
|
|
# 23 "/usr/include/arpa/inet.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
extern in_addr_t inet_addr (const char *__cp) throw ();
|
|
|
|
|
|
extern in_addr_t inet_lnaof (struct in_addr __in) throw ();
|
|
|
|
|
|
|
|
extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
|
|
throw ();
|
|
|
|
|
|
extern in_addr_t inet_netof (struct in_addr __in) throw ();
|
|
|
|
|
|
|
|
extern in_addr_t inet_network (const char *__cp) throw ();
|
|
|
|
|
|
|
|
extern char *inet_ntoa (struct in_addr __in) throw ();
|
|
|
|
|
|
|
|
|
|
extern int inet_pton (int __af, const char *__restrict __cp,
|
|
void *__restrict __buf) throw ();
|
|
|
|
|
|
|
|
|
|
extern const char *inet_ntop (int __af, const void *__restrict __cp,
|
|
char *__restrict __buf, socklen_t __len)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();
|
|
|
|
|
|
|
|
extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();
|
|
|
|
|
|
|
|
|
|
extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
|
|
char *__buf, size_t __len) throw ();
|
|
|
|
|
|
|
|
|
|
extern int inet_net_pton (int __af, const char *__cp,
|
|
void *__buf, size_t __len) throw ();
|
|
|
|
|
|
|
|
|
|
extern unsigned int inet_nsap_addr (const char *__cp,
|
|
unsigned char *__buf, int __len) throw ();
|
|
|
|
|
|
|
|
extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
|
|
char *__buf) throw ();
|
|
|
|
|
|
}
|
|
# 18 "include/CTypedef.h" 2
|
|
# 1 "include/CLog.h" 1
|
|
# 10 "include/CLog.h"
|
|
# 1 "/usr/include/syslog.h" 1 3 4
|
|
# 1 "/usr/include/sys/syslog.h" 1 3 4
|
|
# 37 "/usr/include/sys/syslog.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdarg.h" 1 3 4
|
|
# 38 "/usr/include/sys/syslog.h" 2 3 4
|
|
|
|
|
|
# 1 "/usr/include/bits/syslog-path.h" 1 3 4
|
|
# 41 "/usr/include/sys/syslog.h" 2 3 4
|
|
# 169 "/usr/include/sys/syslog.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
|
|
extern void closelog (void);
|
|
|
|
|
|
|
|
|
|
|
|
extern void openlog (const char *__ident, int __option, int __facility);
|
|
|
|
|
|
extern int setlogmask (int __mask) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern void syslog (int __pri, const char *__fmt, ...)
|
|
__attribute__ ((__format__ (__printf__, 2, 3)));
|
|
# 200 "/usr/include/sys/syslog.h" 3 4
|
|
extern void vsyslog (int __pri, const char *__fmt, __gnuc_va_list __ap)
|
|
__attribute__ ((__format__ (__printf__, 2, 0)));
|
|
# 213 "/usr/include/sys/syslog.h" 3 4
|
|
}
|
|
# 1 "/usr/include/syslog.h" 2 3 4
|
|
# 11 "include/CLog.h" 2
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdarg.h" 1 3 4
|
|
# 98 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stdarg.h" 3 4
|
|
typedef __gnuc_va_list va_list;
|
|
# 12 "include/CLog.h" 2
|
|
# 1 "/usr/include/stdio.h" 1 3 4
|
|
# 29 "/usr/include/stdio.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 34 "/usr/include/stdio.h" 2 3 4
|
|
# 74 "/usr/include/stdio.h" 3 4
|
|
# 1 "/usr/include/libio.h" 1 3 4
|
|
# 32 "/usr/include/libio.h" 3 4
|
|
# 1 "/usr/include/_G_config.h" 1 3 4
|
|
# 15 "/usr/include/_G_config.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 16 "/usr/include/_G_config.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/wchar.h" 1 3 4
|
|
# 21 "/usr/include/_G_config.h" 2 3 4
|
|
typedef struct
|
|
{
|
|
__off_t __pos;
|
|
__mbstate_t __state;
|
|
} _G_fpos_t;
|
|
typedef struct
|
|
{
|
|
__off64_t __pos;
|
|
__mbstate_t __state;
|
|
} _G_fpos64_t;
|
|
# 33 "/usr/include/libio.h" 2 3 4
|
|
# 145 "/usr/include/libio.h" 3 4
|
|
struct _IO_jump_t; struct _IO_FILE;
|
|
# 155 "/usr/include/libio.h" 3 4
|
|
typedef void _IO_lock_t;
|
|
|
|
|
|
|
|
|
|
|
|
struct _IO_marker {
|
|
struct _IO_marker *_next;
|
|
struct _IO_FILE *_sbuf;
|
|
|
|
|
|
|
|
int _pos;
|
|
# 178 "/usr/include/libio.h" 3 4
|
|
};
|
|
|
|
|
|
enum __codecvt_result
|
|
{
|
|
__codecvt_ok,
|
|
__codecvt_partial,
|
|
__codecvt_error,
|
|
__codecvt_noconv
|
|
};
|
|
# 246 "/usr/include/libio.h" 3 4
|
|
struct _IO_FILE {
|
|
int _flags;
|
|
|
|
|
|
|
|
|
|
char* _IO_read_ptr;
|
|
char* _IO_read_end;
|
|
char* _IO_read_base;
|
|
char* _IO_write_base;
|
|
char* _IO_write_ptr;
|
|
char* _IO_write_end;
|
|
char* _IO_buf_base;
|
|
char* _IO_buf_end;
|
|
|
|
char *_IO_save_base;
|
|
char *_IO_backup_base;
|
|
char *_IO_save_end;
|
|
|
|
struct _IO_marker *_markers;
|
|
|
|
struct _IO_FILE *_chain;
|
|
|
|
int _fileno;
|
|
|
|
|
|
|
|
int _flags2;
|
|
|
|
__off_t _old_offset;
|
|
|
|
|
|
|
|
unsigned short _cur_column;
|
|
signed char _vtable_offset;
|
|
char _shortbuf[1];
|
|
|
|
|
|
|
|
_IO_lock_t *_lock;
|
|
# 294 "/usr/include/libio.h" 3 4
|
|
__off64_t _offset;
|
|
# 303 "/usr/include/libio.h" 3 4
|
|
void *__pad1;
|
|
void *__pad2;
|
|
void *__pad3;
|
|
void *__pad4;
|
|
size_t __pad5;
|
|
|
|
int _mode;
|
|
|
|
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct _IO_FILE_plus;
|
|
|
|
extern struct _IO_FILE_plus _IO_2_1_stdin_;
|
|
extern struct _IO_FILE_plus _IO_2_1_stdout_;
|
|
extern struct _IO_FILE_plus _IO_2_1_stderr_;
|
|
# 339 "/usr/include/libio.h" 3 4
|
|
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
|
|
size_t __n);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
|
|
|
|
|
|
typedef int __io_close_fn (void *__cookie);
|
|
|
|
|
|
|
|
|
|
typedef __io_read_fn cookie_read_function_t;
|
|
typedef __io_write_fn cookie_write_function_t;
|
|
typedef __io_seek_fn cookie_seek_function_t;
|
|
typedef __io_close_fn cookie_close_function_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
__io_read_fn *read;
|
|
__io_write_fn *write;
|
|
__io_seek_fn *seek;
|
|
__io_close_fn *close;
|
|
} _IO_cookie_io_functions_t;
|
|
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
|
|
|
|
struct _IO_cookie_file;
|
|
|
|
|
|
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
|
|
void *__cookie, _IO_cookie_io_functions_t __fns);
|
|
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
extern int __underflow (_IO_FILE *);
|
|
extern int __uflow (_IO_FILE *);
|
|
extern int __overflow (_IO_FILE *, int);
|
|
# 435 "/usr/include/libio.h" 3 4
|
|
extern int _IO_getc (_IO_FILE *__fp);
|
|
extern int _IO_putc (int __c, _IO_FILE *__fp);
|
|
extern int _IO_feof (_IO_FILE *__fp) throw ();
|
|
extern int _IO_ferror (_IO_FILE *__fp) throw ();
|
|
|
|
extern int _IO_peekc_locked (_IO_FILE *__fp);
|
|
|
|
|
|
|
|
|
|
|
|
extern void _IO_flockfile (_IO_FILE *) throw ();
|
|
extern void _IO_funlockfile (_IO_FILE *) throw ();
|
|
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
|
|
# 465 "/usr/include/libio.h" 3 4
|
|
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
|
|
__gnuc_va_list, int *__restrict);
|
|
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
|
|
__gnuc_va_list);
|
|
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
|
|
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
|
|
|
|
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
|
|
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
|
|
|
|
extern void _IO_free_backup_area (_IO_FILE *) throw ();
|
|
# 527 "/usr/include/libio.h" 3 4
|
|
}
|
|
# 75 "/usr/include/stdio.h" 2 3 4
|
|
# 108 "/usr/include/stdio.h" 3 4
|
|
|
|
|
|
typedef _G_fpos_t fpos_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef _G_fpos64_t fpos64_t;
|
|
# 164 "/usr/include/stdio.h" 3 4
|
|
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
|
|
# 165 "/usr/include/stdio.h" 2 3 4
|
|
|
|
|
|
|
|
extern struct _IO_FILE *stdin;
|
|
extern struct _IO_FILE *stdout;
|
|
extern struct _IO_FILE *stderr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int remove (const char *__filename) throw ();
|
|
|
|
extern int rename (const char *__old, const char *__new) throw ();
|
|
|
|
|
|
|
|
|
|
extern int renameat (int __oldfd, const char *__old, int __newfd,
|
|
const char *__new) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern FILE *tmpfile (void) ;
|
|
# 205 "/usr/include/stdio.h" 3 4
|
|
extern FILE *tmpfile64 (void) ;
|
|
|
|
|
|
|
|
extern char *tmpnam (char *__s) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern char *tmpnam_r (char *__s) throw () ;
|
|
# 227 "/usr/include/stdio.h" 3 4
|
|
extern char *tempnam (const char *__dir, const char *__pfx)
|
|
throw () __attribute__ ((__malloc__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fclose (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
extern int fflush (FILE *__stream);
|
|
|
|
# 252 "/usr/include/stdio.h" 3 4
|
|
extern int fflush_unlocked (FILE *__stream);
|
|
# 262 "/usr/include/stdio.h" 3 4
|
|
extern int fcloseall (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern FILE *fopen (const char *__restrict __filename,
|
|
const char *__restrict __modes) ;
|
|
|
|
|
|
|
|
|
|
extern FILE *freopen (const char *__restrict __filename,
|
|
const char *__restrict __modes,
|
|
FILE *__restrict __stream) ;
|
|
# 295 "/usr/include/stdio.h" 3 4
|
|
|
|
|
|
extern FILE *fopen64 (const char *__restrict __filename,
|
|
const char *__restrict __modes) ;
|
|
extern FILE *freopen64 (const char *__restrict __filename,
|
|
const char *__restrict __modes,
|
|
FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
extern FILE *fopencookie (void *__restrict __magic_cookie,
|
|
const char *__restrict __modes,
|
|
_IO_cookie_io_functions_t __io_funcs) throw () ;
|
|
|
|
|
|
|
|
|
|
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
|
|
throw () ;
|
|
|
|
|
|
|
|
|
|
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
|
|
|
|
|
|
|
|
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
|
|
int __modes, size_t __n) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
|
|
size_t __size) throw ();
|
|
|
|
|
|
extern void setlinebuf (FILE *__stream) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fprintf (FILE *__restrict __stream,
|
|
const char *__restrict __format, ...);
|
|
|
|
|
|
|
|
|
|
extern int printf (const char *__restrict __format, ...);
|
|
|
|
extern int sprintf (char *__restrict __s,
|
|
const char *__restrict __format, ...) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
|
|
__gnuc_va_list __arg);
|
|
|
|
|
|
|
|
|
|
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
|
|
|
|
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
|
|
__gnuc_va_list __arg) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern int snprintf (char *__restrict __s, size_t __maxlen,
|
|
const char *__restrict __format, ...)
|
|
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
|
|
|
|
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
|
|
const char *__restrict __format, __gnuc_va_list __arg)
|
|
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
|
|
__gnuc_va_list __arg)
|
|
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
|
|
extern int __asprintf (char **__restrict __ptr,
|
|
const char *__restrict __fmt, ...)
|
|
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
|
|
extern int asprintf (char **__restrict __ptr,
|
|
const char *__restrict __fmt, ...)
|
|
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
|
|
|
|
|
|
|
|
|
|
extern int vdprintf (int __fd, const char *__restrict __fmt,
|
|
__gnuc_va_list __arg)
|
|
__attribute__ ((__format__ (__printf__, 2, 0)));
|
|
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
|
|
__attribute__ ((__format__ (__printf__, 2, 3)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fscanf (FILE *__restrict __stream,
|
|
const char *__restrict __format, ...) ;
|
|
|
|
|
|
|
|
|
|
extern int scanf (const char *__restrict __format, ...) ;
|
|
|
|
extern int sscanf (const char *__restrict __s,
|
|
const char *__restrict __format, ...) throw ();
|
|
# 463 "/usr/include/stdio.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
|
|
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
|
|
|
|
|
|
extern int vsscanf (const char *__restrict __s,
|
|
const char *__restrict __format, __gnuc_va_list __arg)
|
|
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
|
|
# 522 "/usr/include/stdio.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fgetc (FILE *__stream);
|
|
extern int getc (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int getchar (void);
|
|
|
|
# 550 "/usr/include/stdio.h" 3 4
|
|
extern int getc_unlocked (FILE *__stream);
|
|
extern int getchar_unlocked (void);
|
|
# 561 "/usr/include/stdio.h" 3 4
|
|
extern int fgetc_unlocked (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fputc (int __c, FILE *__stream);
|
|
extern int putc (int __c, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int putchar (int __c);
|
|
|
|
# 594 "/usr/include/stdio.h" 3 4
|
|
extern int fputc_unlocked (int __c, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int putc_unlocked (int __c, FILE *__stream);
|
|
extern int putchar_unlocked (int __c);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int getw (FILE *__stream);
|
|
|
|
|
|
extern int putw (int __w, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
|
|
;
|
|
# 638 "/usr/include/stdio.h" 3 4
|
|
extern char *gets (char *__s) __attribute__ ((__deprecated__));
|
|
|
|
|
|
# 649 "/usr/include/stdio.h" 3 4
|
|
extern char *fgets_unlocked (char *__restrict __s, int __n,
|
|
FILE *__restrict __stream) ;
|
|
# 665 "/usr/include/stdio.h" 3 4
|
|
extern __ssize_t __getdelim (char **__restrict __lineptr,
|
|
size_t *__restrict __n, int __delimiter,
|
|
FILE *__restrict __stream) ;
|
|
extern __ssize_t getdelim (char **__restrict __lineptr,
|
|
size_t *__restrict __n, int __delimiter,
|
|
FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __ssize_t getline (char **__restrict __lineptr,
|
|
size_t *__restrict __n,
|
|
FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int puts (const char *__s);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int ungetc (int __c, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t fread (void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __s);
|
|
|
|
# 726 "/usr/include/stdio.h" 3 4
|
|
extern int fputs_unlocked (const char *__restrict __s,
|
|
FILE *__restrict __stream);
|
|
# 737 "/usr/include/stdio.h" 3 4
|
|
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __stream) ;
|
|
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fseek (FILE *__stream, long int __off, int __whence);
|
|
|
|
|
|
|
|
|
|
extern long int ftell (FILE *__stream) ;
|
|
|
|
|
|
|
|
|
|
extern void rewind (FILE *__stream);
|
|
|
|
# 773 "/usr/include/stdio.h" 3 4
|
|
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
|
|
|
|
|
|
|
|
|
|
extern __off_t ftello (FILE *__stream) ;
|
|
# 792 "/usr/include/stdio.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
|
|
|
|
|
|
|
|
|
|
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
|
|
# 815 "/usr/include/stdio.h" 3 4
|
|
|
|
|
|
|
|
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
|
|
extern __off64_t ftello64 (FILE *__stream) ;
|
|
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
|
|
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
|
|
|
|
|
|
|
|
|
|
extern void clearerr (FILE *__stream) throw ();
|
|
|
|
extern int feof (FILE *__stream) throw () ;
|
|
|
|
extern int ferror (FILE *__stream) throw () ;
|
|
|
|
|
|
|
|
|
|
extern void clearerr_unlocked (FILE *__stream) throw ();
|
|
extern int feof_unlocked (FILE *__stream) throw () ;
|
|
extern int ferror_unlocked (FILE *__stream) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void perror (const char *__s);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
|
|
# 26 "/usr/include/bits/sys_errlist.h" 3 4
|
|
extern int sys_nerr;
|
|
extern const char *const sys_errlist[];
|
|
|
|
|
|
extern int _sys_nerr;
|
|
extern const char *const _sys_errlist[];
|
|
# 854 "/usr/include/stdio.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
extern int fileno (FILE *__stream) throw () ;
|
|
|
|
|
|
|
|
|
|
extern int fileno_unlocked (FILE *__stream) throw () ;
|
|
# 873 "/usr/include/stdio.h" 3 4
|
|
extern FILE *popen (const char *__command, const char *__modes) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int pclose (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern char *ctermid (char *__s) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern char *cuserid (char *__s);
|
|
|
|
|
|
|
|
|
|
struct obstack;
|
|
|
|
|
|
extern int obstack_printf (struct obstack *__restrict __obstack,
|
|
const char *__restrict __format, ...)
|
|
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
|
|
extern int obstack_vprintf (struct obstack *__restrict __obstack,
|
|
const char *__restrict __format,
|
|
__gnuc_va_list __args)
|
|
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void flockfile (FILE *__stream) throw ();
|
|
|
|
|
|
|
|
extern int ftrylockfile (FILE *__stream) throw () ;
|
|
|
|
|
|
extern void funlockfile (FILE *__stream) throw ();
|
|
# 943 "/usr/include/stdio.h" 3 4
|
|
}
|
|
# 13 "include/CLog.h" 2
|
|
# 1 "/usr/include/signal.h" 1 3 4
|
|
# 30 "/usr/include/signal.h" 3 4
|
|
extern "C" {
|
|
|
|
# 1 "/usr/include/bits/sigset.h" 1 3 4
|
|
# 103 "/usr/include/bits/sigset.h" 3 4
|
|
extern int __sigismember (const __sigset_t *, int);
|
|
extern int __sigaddset (__sigset_t *, int);
|
|
extern int __sigdelset (__sigset_t *, int);
|
|
# 33 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __sig_atomic_t sig_atomic_t;
|
|
|
|
# 57 "/usr/include/signal.h" 3 4
|
|
# 1 "/usr/include/bits/signum.h" 1 3 4
|
|
# 58 "/usr/include/signal.h" 2 3 4
|
|
# 80 "/usr/include/signal.h" 3 4
|
|
# 1 "/usr/include/bits/siginfo.h" 1 3 4
|
|
# 24 "/usr/include/bits/siginfo.h" 3 4
|
|
# 1 "/usr/include/bits/wordsize.h" 1 3 4
|
|
# 25 "/usr/include/bits/siginfo.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef union sigval
|
|
{
|
|
int sival_int;
|
|
void *sival_ptr;
|
|
} sigval_t;
|
|
# 58 "/usr/include/bits/siginfo.h" 3 4
|
|
typedef __clock_t __sigchld_clock_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int si_signo;
|
|
int si_errno;
|
|
|
|
int si_code;
|
|
|
|
union
|
|
{
|
|
int _pad[((128 / sizeof (int)) - 4)];
|
|
|
|
|
|
struct
|
|
{
|
|
__pid_t si_pid;
|
|
__uid_t si_uid;
|
|
} _kill;
|
|
|
|
|
|
struct
|
|
{
|
|
int si_tid;
|
|
int si_overrun;
|
|
sigval_t si_sigval;
|
|
} _timer;
|
|
|
|
|
|
struct
|
|
{
|
|
__pid_t si_pid;
|
|
__uid_t si_uid;
|
|
sigval_t si_sigval;
|
|
} _rt;
|
|
|
|
|
|
struct
|
|
{
|
|
__pid_t si_pid;
|
|
__uid_t si_uid;
|
|
int si_status;
|
|
__sigchld_clock_t si_utime;
|
|
__sigchld_clock_t si_stime;
|
|
} _sigchld;
|
|
|
|
|
|
struct
|
|
{
|
|
void *si_addr;
|
|
} _sigfault;
|
|
|
|
|
|
struct
|
|
{
|
|
long int si_band;
|
|
int si_fd;
|
|
} _sigpoll;
|
|
|
|
|
|
struct
|
|
{
|
|
void *_call_addr;
|
|
int _syscall;
|
|
unsigned int _arch;
|
|
} _sigsys;
|
|
} _sifields;
|
|
} siginfo_t ;
|
|
# 151 "/usr/include/bits/siginfo.h" 3 4
|
|
enum
|
|
{
|
|
SI_ASYNCNL = -60,
|
|
|
|
SI_TKILL = -6,
|
|
|
|
SI_SIGIO,
|
|
|
|
SI_ASYNCIO,
|
|
|
|
SI_MESGQ,
|
|
|
|
SI_TIMER,
|
|
|
|
SI_QUEUE,
|
|
|
|
SI_USER,
|
|
|
|
SI_KERNEL = 0x80
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
ILL_ILLOPC = 1,
|
|
|
|
ILL_ILLOPN,
|
|
|
|
ILL_ILLADR,
|
|
|
|
ILL_ILLTRP,
|
|
|
|
ILL_PRVOPC,
|
|
|
|
ILL_PRVREG,
|
|
|
|
ILL_COPROC,
|
|
|
|
ILL_BADSTK
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
FPE_INTDIV = 1,
|
|
|
|
FPE_INTOVF,
|
|
|
|
FPE_FLTDIV,
|
|
|
|
FPE_FLTOVF,
|
|
|
|
FPE_FLTUND,
|
|
|
|
FPE_FLTRES,
|
|
|
|
FPE_FLTINV,
|
|
|
|
FPE_FLTSUB
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
SEGV_MAPERR = 1,
|
|
|
|
SEGV_ACCERR
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
BUS_ADRALN = 1,
|
|
|
|
BUS_ADRERR,
|
|
|
|
BUS_OBJERR
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
TRAP_BRKPT = 1,
|
|
|
|
TRAP_TRACE
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
CLD_EXITED = 1,
|
|
|
|
CLD_KILLED,
|
|
|
|
CLD_DUMPED,
|
|
|
|
CLD_TRAPPED,
|
|
|
|
CLD_STOPPED,
|
|
|
|
CLD_CONTINUED
|
|
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
POLL_IN = 1,
|
|
|
|
POLL_OUT,
|
|
|
|
POLL_MSG,
|
|
|
|
POLL_ERR,
|
|
|
|
POLL_PRI,
|
|
|
|
POLL_HUP
|
|
|
|
};
|
|
# 301 "/usr/include/bits/siginfo.h" 3 4
|
|
typedef struct sigevent
|
|
{
|
|
sigval_t sigev_value;
|
|
int sigev_signo;
|
|
int sigev_notify;
|
|
|
|
union
|
|
{
|
|
int _pad[((64 / sizeof (int)) - 4)];
|
|
|
|
|
|
|
|
__pid_t _tid;
|
|
|
|
struct
|
|
{
|
|
void (*_function) (sigval_t);
|
|
pthread_attr_t *_attribute;
|
|
} _sigev_thread;
|
|
} _sigev_un;
|
|
} sigevent_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
SIGEV_SIGNAL = 0,
|
|
|
|
SIGEV_NONE,
|
|
|
|
SIGEV_THREAD,
|
|
|
|
|
|
SIGEV_THREAD_ID = 4
|
|
|
|
};
|
|
# 81 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
typedef void (*__sighandler_t) (int);
|
|
|
|
|
|
|
|
|
|
extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
|
|
throw ();
|
|
|
|
extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
|
|
throw ();
|
|
# 114 "/usr/include/signal.h" 3 4
|
|
|
|
|
|
|
|
|
|
|
|
extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int kill (__pid_t __pid, int __sig) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int killpg (__pid_t __pgrp, int __sig) throw ();
|
|
|
|
|
|
|
|
|
|
extern int raise (int __sig) throw ();
|
|
|
|
|
|
|
|
|
|
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
|
|
throw ();
|
|
extern int gsignal (int __sig) throw ();
|
|
|
|
|
|
|
|
|
|
extern void psignal (int __sig, const char *__s);
|
|
|
|
|
|
|
|
|
|
extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
|
|
# 169 "/usr/include/signal.h" 3 4
|
|
extern int __sigpause (int __sig_or_mask, int __is_sig);
|
|
# 178 "/usr/include/signal.h" 3 4
|
|
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
|
|
# 197 "/usr/include/signal.h" 3 4
|
|
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
|
|
|
|
|
|
extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
|
|
|
|
|
|
extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
|
|
# 212 "/usr/include/signal.h" 3 4
|
|
typedef __sighandler_t sighandler_t;
|
|
|
|
|
|
|
|
|
|
typedef __sighandler_t sig_t;
|
|
|
|
|
|
|
|
|
|
|
|
extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int sigismember (const sigset_t *__set, int __signo)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int sigandset (sigset_t *__set, const sigset_t *__left,
|
|
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
|
|
|
|
|
|
extern int sigorset (sigset_t *__set, const sigset_t *__left,
|
|
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/sigaction.h" 1 3 4
|
|
# 24 "/usr/include/bits/sigaction.h" 3 4
|
|
struct sigaction
|
|
{
|
|
|
|
|
|
union
|
|
{
|
|
|
|
__sighandler_t sa_handler;
|
|
|
|
void (*sa_sigaction) (int, siginfo_t *, void *);
|
|
}
|
|
__sigaction_handler;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__sigset_t sa_mask;
|
|
|
|
|
|
int sa_flags;
|
|
|
|
|
|
void (*sa_restorer) (void);
|
|
};
|
|
# 254 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
extern int sigprocmask (int __how, const sigset_t *__restrict __set,
|
|
sigset_t *__restrict __oset) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int sigaction (int __sig, const struct sigaction *__restrict __act,
|
|
struct sigaction *__restrict __oact) throw ();
|
|
|
|
|
|
extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
|
|
__attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sigwaitinfo (const sigset_t *__restrict __set,
|
|
siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sigtimedwait (const sigset_t *__restrict __set,
|
|
siginfo_t *__restrict __info,
|
|
const struct timespec *__restrict __timeout)
|
|
__attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
|
|
throw ();
|
|
# 311 "/usr/include/signal.h" 3 4
|
|
extern const char *const _sys_siglist[65];
|
|
extern const char *const sys_siglist[65];
|
|
|
|
|
|
struct sigvec
|
|
{
|
|
__sighandler_t sv_handler;
|
|
int sv_mask;
|
|
|
|
int sv_flags;
|
|
|
|
};
|
|
# 335 "/usr/include/signal.h" 3 4
|
|
extern int sigvec (int __sig, const struct sigvec *__vec,
|
|
struct sigvec *__ovec) throw ();
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/sigcontext.h" 1 3 4
|
|
# 29 "/usr/include/bits/sigcontext.h" 3 4
|
|
struct _fpx_sw_bytes
|
|
{
|
|
__uint32_t magic1;
|
|
__uint32_t extended_size;
|
|
__uint64_t xstate_bv;
|
|
__uint32_t xstate_size;
|
|
__uint32_t padding[7];
|
|
};
|
|
|
|
struct _fpreg
|
|
{
|
|
unsigned short significand[4];
|
|
unsigned short exponent;
|
|
};
|
|
|
|
struct _fpxreg
|
|
{
|
|
unsigned short significand[4];
|
|
unsigned short exponent;
|
|
unsigned short padding[3];
|
|
};
|
|
|
|
struct _xmmreg
|
|
{
|
|
__uint32_t element[4];
|
|
};
|
|
# 121 "/usr/include/bits/sigcontext.h" 3 4
|
|
struct _fpstate
|
|
{
|
|
|
|
__uint16_t cwd;
|
|
__uint16_t swd;
|
|
__uint16_t ftw;
|
|
__uint16_t fop;
|
|
__uint64_t rip;
|
|
__uint64_t rdp;
|
|
__uint32_t mxcsr;
|
|
__uint32_t mxcr_mask;
|
|
struct _fpxreg _st[8];
|
|
struct _xmmreg _xmm[16];
|
|
__uint32_t padding[24];
|
|
};
|
|
|
|
struct sigcontext
|
|
{
|
|
__uint64_t r8;
|
|
__uint64_t r9;
|
|
__uint64_t r10;
|
|
__uint64_t r11;
|
|
__uint64_t r12;
|
|
__uint64_t r13;
|
|
__uint64_t r14;
|
|
__uint64_t r15;
|
|
__uint64_t rdi;
|
|
__uint64_t rsi;
|
|
__uint64_t rbp;
|
|
__uint64_t rbx;
|
|
__uint64_t rdx;
|
|
__uint64_t rax;
|
|
__uint64_t rcx;
|
|
__uint64_t rsp;
|
|
__uint64_t rip;
|
|
__uint64_t eflags;
|
|
unsigned short cs;
|
|
unsigned short gs;
|
|
unsigned short fs;
|
|
unsigned short __pad0;
|
|
__uint64_t err;
|
|
__uint64_t trapno;
|
|
__uint64_t oldmask;
|
|
__uint64_t cr2;
|
|
__extension__ union
|
|
{
|
|
struct _fpstate * fpstate;
|
|
__uint64_t __fpstate_word;
|
|
};
|
|
__uint64_t __reserved1 [8];
|
|
};
|
|
|
|
|
|
|
|
struct _xsave_hdr
|
|
{
|
|
__uint64_t xstate_bv;
|
|
__uint64_t reserved1[2];
|
|
__uint64_t reserved2[5];
|
|
};
|
|
|
|
struct _ymmh_state
|
|
{
|
|
__uint32_t ymmh_space[64];
|
|
};
|
|
|
|
struct _xstate
|
|
{
|
|
struct _fpstate fpstate;
|
|
struct _xsave_hdr xstate_hdr;
|
|
struct _ymmh_state ymmh;
|
|
};
|
|
# 341 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
extern int sigreturn (struct sigcontext *__scp) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 351 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
extern int siginterrupt (int __sig, int __interrupt) throw ();
|
|
|
|
# 1 "/usr/include/bits/sigstack.h" 1 3 4
|
|
# 25 "/usr/include/bits/sigstack.h" 3 4
|
|
struct sigstack
|
|
{
|
|
void *ss_sp;
|
|
int ss_onstack;
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
SS_ONSTACK = 1,
|
|
|
|
SS_DISABLE
|
|
|
|
};
|
|
# 49 "/usr/include/bits/sigstack.h" 3 4
|
|
typedef struct sigaltstack
|
|
{
|
|
void *ss_sp;
|
|
int ss_flags;
|
|
size_t ss_size;
|
|
} stack_t;
|
|
# 358 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
# 1 "/usr/include/sys/ucontext.h" 1 3 4
|
|
# 22 "/usr/include/sys/ucontext.h" 3 4
|
|
# 1 "/usr/include/signal.h" 1 3 4
|
|
# 23 "/usr/include/sys/ucontext.h" 2 3 4
|
|
# 31 "/usr/include/sys/ucontext.h" 3 4
|
|
__extension__ typedef long long int greg_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef greg_t gregset_t[23];
|
|
|
|
|
|
|
|
enum
|
|
{
|
|
REG_R8 = 0,
|
|
|
|
REG_R9,
|
|
|
|
REG_R10,
|
|
|
|
REG_R11,
|
|
|
|
REG_R12,
|
|
|
|
REG_R13,
|
|
|
|
REG_R14,
|
|
|
|
REG_R15,
|
|
|
|
REG_RDI,
|
|
|
|
REG_RSI,
|
|
|
|
REG_RBP,
|
|
|
|
REG_RBX,
|
|
|
|
REG_RDX,
|
|
|
|
REG_RAX,
|
|
|
|
REG_RCX,
|
|
|
|
REG_RSP,
|
|
|
|
REG_RIP,
|
|
|
|
REG_EFL,
|
|
|
|
REG_CSGSFS,
|
|
|
|
REG_ERR,
|
|
|
|
REG_TRAPNO,
|
|
|
|
REG_OLDMASK,
|
|
|
|
REG_CR2
|
|
|
|
};
|
|
|
|
|
|
struct _libc_fpxreg
|
|
{
|
|
unsigned short int significand[4];
|
|
unsigned short int exponent;
|
|
unsigned short int padding[3];
|
|
};
|
|
|
|
struct _libc_xmmreg
|
|
{
|
|
__uint32_t element[4];
|
|
};
|
|
|
|
struct _libc_fpstate
|
|
{
|
|
|
|
__uint16_t cwd;
|
|
__uint16_t swd;
|
|
__uint16_t ftw;
|
|
__uint16_t fop;
|
|
__uint64_t rip;
|
|
__uint64_t rdp;
|
|
__uint32_t mxcsr;
|
|
__uint32_t mxcr_mask;
|
|
struct _libc_fpxreg _st[8];
|
|
struct _libc_xmmreg _xmm[16];
|
|
__uint32_t padding[24];
|
|
};
|
|
|
|
|
|
typedef struct _libc_fpstate *fpregset_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
gregset_t gregs;
|
|
|
|
fpregset_t fpregs;
|
|
__extension__ unsigned long long __reserved1 [8];
|
|
} mcontext_t;
|
|
|
|
|
|
typedef struct ucontext
|
|
{
|
|
unsigned long int uc_flags;
|
|
struct ucontext *uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
__sigset_t uc_sigmask;
|
|
struct _libc_fpstate __fpregs_mem;
|
|
} ucontext_t;
|
|
# 361 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
|
|
throw () __attribute__ ((__deprecated__));
|
|
|
|
|
|
|
|
extern int sigaltstack (const struct sigaltstack *__restrict __ss,
|
|
struct sigaltstack *__restrict __oss) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int sighold (int __sig) throw ();
|
|
|
|
|
|
extern int sigrelse (int __sig) throw ();
|
|
|
|
|
|
extern int sigignore (int __sig) throw ();
|
|
|
|
|
|
extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/sigthread.h" 1 3 4
|
|
# 30 "/usr/include/bits/sigthread.h" 3 4
|
|
extern int pthread_sigmask (int __how,
|
|
const __sigset_t *__restrict __newmask,
|
|
__sigset_t *__restrict __oldmask)throw ();
|
|
|
|
|
|
extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
|
|
|
|
|
|
|
|
extern int pthread_sigqueue (pthread_t __threadid, int __signo,
|
|
const union sigval __value) throw ();
|
|
# 397 "/usr/include/signal.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int __libc_current_sigrtmin (void) throw ();
|
|
|
|
extern int __libc_current_sigrtmax (void) throw ();
|
|
|
|
|
|
|
|
}
|
|
# 14 "include/CLog.h" 2
|
|
# 1 "/usr/include/stdlib.h" 1 3 4
|
|
# 32 "/usr/include/stdlib.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 33 "/usr/include/stdlib.h" 2 3 4
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/include/bits/waitflags.h" 1 3 4
|
|
# 42 "/usr/include/stdlib.h" 2 3 4
|
|
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
|
|
# 66 "/usr/include/bits/waitstatus.h" 3 4
|
|
union wait
|
|
{
|
|
int w_status;
|
|
struct
|
|
{
|
|
|
|
unsigned int __w_termsig:7;
|
|
unsigned int __w_coredump:1;
|
|
unsigned int __w_retcode:8;
|
|
unsigned int:16;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} __wait_terminated;
|
|
struct
|
|
{
|
|
|
|
unsigned int __w_stopval:8;
|
|
unsigned int __w_stopsig:8;
|
|
unsigned int:16;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} __wait_stopped;
|
|
};
|
|
# 43 "/usr/include/stdlib.h" 2 3 4
|
|
# 95 "/usr/include/stdlib.h" 3 4
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int quot;
|
|
int rem;
|
|
} div_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
long int quot;
|
|
long int rem;
|
|
} ldiv_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__extension__ typedef struct
|
|
{
|
|
long long int quot;
|
|
long long int rem;
|
|
} lldiv_t;
|
|
|
|
|
|
# 139 "/usr/include/stdlib.h" 3 4
|
|
extern size_t __ctype_get_mb_cur_max (void) throw () ;
|
|
|
|
|
|
|
|
|
|
extern double atof (const char *__nptr)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
extern int atoi (const char *__nptr)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
extern long int atol (const char *__nptr)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
__extension__ extern long long int atoll (const char *__nptr)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern double strtod (const char *__restrict __nptr,
|
|
char **__restrict __endptr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern float strtof (const char *__restrict __nptr,
|
|
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
extern long double strtold (const char *__restrict __nptr,
|
|
char **__restrict __endptr)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern long int strtol (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
extern unsigned long int strtoul (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
__extension__
|
|
extern long long int strtoq (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
__extension__
|
|
extern unsigned long long int strtouq (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
__extension__
|
|
extern long long int strtoll (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
__extension__
|
|
extern unsigned long long int strtoull (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
# 239 "/usr/include/stdlib.h" 3 4
|
|
extern long int strtol_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base,
|
|
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
|
|
|
|
extern unsigned long int strtoul_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr,
|
|
int __base, __locale_t __loc)
|
|
throw () __attribute__ ((__nonnull__ (1, 4)));
|
|
|
|
__extension__
|
|
extern long long int strtoll_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base,
|
|
__locale_t __loc)
|
|
throw () __attribute__ ((__nonnull__ (1, 4)));
|
|
|
|
__extension__
|
|
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr,
|
|
int __base, __locale_t __loc)
|
|
throw () __attribute__ ((__nonnull__ (1, 4)));
|
|
|
|
extern double strtod_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr, __locale_t __loc)
|
|
throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
extern float strtof_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr, __locale_t __loc)
|
|
throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
extern long double strtold_l (const char *__restrict __nptr,
|
|
char **__restrict __endptr,
|
|
__locale_t __loc)
|
|
throw () __attribute__ ((__nonnull__ (1, 3)));
|
|
# 305 "/usr/include/stdlib.h" 3 4
|
|
extern char *l64a (long int __n) throw () ;
|
|
|
|
|
|
extern long int a64l (const char *__s)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
# 321 "/usr/include/stdlib.h" 3 4
|
|
extern long int random (void) throw ();
|
|
|
|
|
|
extern void srandom (unsigned int __seed) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern char *initstate (unsigned int __seed, char *__statebuf,
|
|
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct random_data
|
|
{
|
|
int32_t *fptr;
|
|
int32_t *rptr;
|
|
int32_t *state;
|
|
int rand_type;
|
|
int rand_deg;
|
|
int rand_sep;
|
|
int32_t *end_ptr;
|
|
};
|
|
|
|
extern int random_r (struct random_data *__restrict __buf,
|
|
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
|
|
size_t __statelen,
|
|
struct random_data *__restrict __buf)
|
|
throw () __attribute__ ((__nonnull__ (2, 4)));
|
|
|
|
extern int setstate_r (char *__restrict __statebuf,
|
|
struct random_data *__restrict __buf)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int rand (void) throw ();
|
|
|
|
extern void srand (unsigned int __seed) throw ();
|
|
|
|
|
|
|
|
|
|
extern int rand_r (unsigned int *__seed) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern double drand48 (void) throw ();
|
|
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern long int lrand48 (void) throw ();
|
|
extern long int nrand48 (unsigned short int __xsubi[3])
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern long int mrand48 (void) throw ();
|
|
extern long int jrand48 (unsigned short int __xsubi[3])
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern void srand48 (long int __seedval) throw ();
|
|
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
struct drand48_data
|
|
{
|
|
unsigned short int __x[3];
|
|
unsigned short int __old_x[3];
|
|
unsigned short int __c;
|
|
unsigned short int __init;
|
|
unsigned long long int __a;
|
|
};
|
|
|
|
|
|
extern int drand48_r (struct drand48_data *__restrict __buffer,
|
|
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
extern int erand48_r (unsigned short int __xsubi[3],
|
|
struct drand48_data *__restrict __buffer,
|
|
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int lrand48_r (struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
extern int nrand48_r (unsigned short int __xsubi[3],
|
|
struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int mrand48_r (struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
extern int jrand48_r (unsigned short int __xsubi[3],
|
|
struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
extern int seed48_r (unsigned short int __seed16v[3],
|
|
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern int lcong48_r (unsigned short int __param[7],
|
|
struct drand48_data *__buffer)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
|
|
|
|
extern void *calloc (size_t __nmemb, size_t __size)
|
|
throw () __attribute__ ((__malloc__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *realloc (void *__ptr, size_t __size)
|
|
throw () __attribute__ ((__warn_unused_result__));
|
|
|
|
extern void free (void *__ptr) throw ();
|
|
|
|
|
|
|
|
|
|
extern void cfree (void *__ptr) throw ();
|
|
|
|
|
|
|
|
# 1 "/usr/include/alloca.h" 1 3 4
|
|
# 24 "/usr/include/alloca.h" 3 4
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 25 "/usr/include/alloca.h" 2 3 4
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
|
|
extern void *alloca (size_t __size) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
# 492 "/usr/include/stdlib.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
|
|
|
|
|
|
|
|
|
|
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
extern void *aligned_alloc (size_t __alignment, size_t __size)
|
|
throw () __attribute__ ((__malloc__, __alloc_size__ (2)));
|
|
|
|
|
|
|
|
|
|
extern void abort (void) throw () __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
extern "C++" int at_quick_exit (void (*__func) (void))
|
|
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern char *secure_getenv (const char *__name)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int setenv (const char *__name, const char *__value, int __replace)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int clearenv (void) throw ();
|
|
# 605 "/usr/include/stdlib.h" 3 4
|
|
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
|
|
# 619 "/usr/include/stdlib.h" 3 4
|
|
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
|
|
# 629 "/usr/include/stdlib.h" 3 4
|
|
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
|
|
# 641 "/usr/include/stdlib.h" 3 4
|
|
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
|
|
# 651 "/usr/include/stdlib.h" 3 4
|
|
extern int mkstemps64 (char *__template, int __suffixlen)
|
|
__attribute__ ((__nonnull__ (1))) ;
|
|
# 662 "/usr/include/stdlib.h" 3 4
|
|
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
|
|
# 673 "/usr/include/stdlib.h" 3 4
|
|
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
|
|
# 683 "/usr/include/stdlib.h" 3 4
|
|
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
|
|
# 693 "/usr/include/stdlib.h" 3 4
|
|
extern int mkostemps (char *__template, int __suffixlen, int __flags)
|
|
__attribute__ ((__nonnull__ (1))) ;
|
|
# 705 "/usr/include/stdlib.h" 3 4
|
|
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
|
|
__attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int system (const char *__command) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *canonicalize_file_name (const char *__name)
|
|
throw () __attribute__ ((__nonnull__ (1))) ;
|
|
# 733 "/usr/include/stdlib.h" 3 4
|
|
extern char *realpath (const char *__restrict __name,
|
|
char *__restrict __resolved) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef int (*__compar_fn_t) (const void *, const void *);
|
|
|
|
|
|
typedef __compar_fn_t comparison_fn_t;
|
|
|
|
|
|
|
|
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
|
|
|
|
|
|
|
|
|
|
|
|
extern void *bsearch (const void *__key, const void *__base,
|
|
size_t __nmemb, size_t __size, __compar_fn_t __compar)
|
|
__attribute__ ((__nonnull__ (1, 2, 5))) ;
|
|
|
|
|
|
|
|
extern void qsort (void *__base, size_t __nmemb, size_t __size,
|
|
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
|
|
|
|
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
|
|
__compar_d_fn_t __compar, void *__arg)
|
|
__attribute__ ((__nonnull__ (1, 4)));
|
|
|
|
|
|
|
|
|
|
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
|
|
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
|
|
|
|
|
|
|
|
__extension__ extern long long int llabs (long long int __x)
|
|
throw () __attribute__ ((__const__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern div_t div (int __numer, int __denom)
|
|
throw () __attribute__ ((__const__)) ;
|
|
extern ldiv_t ldiv (long int __numer, long int __denom)
|
|
throw () __attribute__ ((__const__)) ;
|
|
|
|
|
|
|
|
|
|
__extension__ extern lldiv_t lldiv (long long int __numer,
|
|
long long int __denom)
|
|
throw () __attribute__ ((__const__)) ;
|
|
|
|
# 807 "/usr/include/stdlib.h" 3 4
|
|
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
|
|
|
|
|
|
|
|
|
|
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
|
|
|
|
|
|
|
|
|
|
extern char *gcvt (double __value, int __ndigit, char *__buf)
|
|
throw () __attribute__ ((__nonnull__ (3))) ;
|
|
|
|
|
|
|
|
|
|
extern char *qecvt (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign)
|
|
throw () __attribute__ ((__nonnull__ (3, 4))) ;
|
|
extern char *qfcvt (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign)
|
|
throw () __attribute__ ((__nonnull__ (3, 4))) ;
|
|
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
|
|
throw () __attribute__ ((__nonnull__ (3))) ;
|
|
|
|
|
|
|
|
|
|
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign, char *__restrict __buf,
|
|
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign, char *__restrict __buf,
|
|
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
|
|
extern int qecvt_r (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign,
|
|
char *__restrict __buf, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
extern int qfcvt_r (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign,
|
|
char *__restrict __buf, size_t __len)
|
|
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int mblen (const char *__s, size_t __n) throw () ;
|
|
|
|
|
|
extern int mbtowc (wchar_t *__restrict __pwc,
|
|
const char *__restrict __s, size_t __n) throw () ;
|
|
|
|
|
|
extern int wctomb (char *__s, wchar_t __wchar) throw () ;
|
|
|
|
|
|
|
|
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
|
|
const char *__restrict __s, size_t __n) throw ();
|
|
|
|
extern size_t wcstombs (char *__restrict __s,
|
|
const wchar_t *__restrict __pwcs, size_t __n)
|
|
throw ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
|
|
# 895 "/usr/include/stdlib.h" 3 4
|
|
extern int getsubopt (char **__restrict __optionp,
|
|
char *const *__restrict __tokens,
|
|
char **__restrict __valuep)
|
|
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int posix_openpt (int __oflag) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int grantpt (int __fd) throw ();
|
|
|
|
|
|
|
|
extern int unlockpt (int __fd) throw ();
|
|
|
|
|
|
|
|
|
|
extern char *ptsname (int __fd) throw () ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
extern int getpt (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int getloadavg (double __loadavg[], int __nelem)
|
|
throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
|
|
# 952 "/usr/include/stdlib.h" 2 3 4
|
|
# 964 "/usr/include/stdlib.h" 3 4
|
|
}
|
|
# 15 "include/CLog.h" 2
|
|
|
|
# 1 "/usr/include/memory.h" 1 3 4
|
|
# 29 "/usr/include/memory.h" 3 4
|
|
# 1 "/usr/include/string.h" 1 3 4
|
|
# 27 "/usr/include/string.h" 3 4
|
|
extern "C" {
|
|
|
|
|
|
|
|
|
|
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.5/include/stddef.h" 1 3 4
|
|
# 33 "/usr/include/string.h" 2 3 4
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
|
|
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern void *memmove (void *__dest, const void *__src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
|
|
int __c, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern void *memchr (void *__s, int __c, size_t __n)
|
|
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern const void *memchr (const void *__s, int __c, size_t __n)
|
|
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
# 90 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" void *rawmemchr (void *__s, int __c)
|
|
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern "C++" const void *rawmemchr (const void *__s, int __c)
|
|
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
|
|
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
|
|
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern char *strncpy (char *__restrict __dest,
|
|
const char *__restrict __src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
|
|
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int strcmp (const char *__s1, const char *__s2)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int strcoll (const char *__s1, const char *__s2)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern size_t strxfrm (char *__restrict __dest,
|
|
const char *__restrict __src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
# 162 "/usr/include/string.h" 3 4
|
|
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
|
|
|
|
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
|
|
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strdup (const char *__s)
|
|
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strndup (const char *__string, size_t __n)
|
|
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
|
|
# 207 "/usr/include/string.h" 3 4
|
|
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern char *strchr (char *__s, int __c)
|
|
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern const char *strchr (const char *__s, int __c)
|
|
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
# 230 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern char *strrchr (char *__s, int __c)
|
|
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern const char *strrchr (const char *__s, int __c)
|
|
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
# 257 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" char *strchrnul (char *__s, int __c)
|
|
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern "C++" const char *strchrnul (const char *__s, int __c)
|
|
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t strcspn (const char *__s, const char *__reject)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern size_t strspn (const char *__s, const char *__accept)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern char *strpbrk (char *__s, const char *__accept)
|
|
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
extern const char *strpbrk (const char *__s, const char *__accept)
|
|
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
# 309 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern char *strstr (char *__haystack, const char *__needle)
|
|
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
extern const char *strstr (const char *__haystack, const char *__needle)
|
|
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
# 336 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
|
|
throw () __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
|
|
extern char *__strtok_r (char *__restrict __s,
|
|
const char *__restrict __delim,
|
|
char **__restrict __save_ptr)
|
|
throw () __attribute__ ((__nonnull__ (2, 3)));
|
|
|
|
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
|
|
char **__restrict __save_ptr)
|
|
throw () __attribute__ ((__nonnull__ (2, 3)));
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
|
|
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
extern "C++" const char *strcasestr (const char *__haystack,
|
|
const char *__needle)
|
|
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
# 378 "/usr/include/string.h" 3 4
|
|
extern void *memmem (const void *__haystack, size_t __haystacklen,
|
|
const void *__needle, size_t __needlelen)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
|
|
|
|
|
|
|
|
extern void *__mempcpy (void *__restrict __dest,
|
|
const void *__restrict __src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
extern void *mempcpy (void *__restrict __dest,
|
|
const void *__restrict __src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t strlen (const char *__s)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t strnlen (const char *__string, size_t __maxlen)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strerror (int __errnum) throw ();
|
|
|
|
# 434 "/usr/include/string.h" 3 4
|
|
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
|
|
throw () __attribute__ ((__nonnull__ (2))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strerror_l (int __errnum, __locale_t __l) throw ();
|
|
|
|
|
|
|
|
|
|
|
|
extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern void bcopy (const void *__src, void *__dest, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern char *index (char *__s, int __c)
|
|
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern const char *index (const char *__s, int __c)
|
|
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
# 483 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++"
|
|
{
|
|
extern char *rindex (char *__s, int __c)
|
|
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
extern const char *rindex (const char *__s, int __c)
|
|
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
|
|
# 511 "/usr/include/string.h" 3 4
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int ffs (int __i) throw () __attribute__ ((__const__));
|
|
|
|
|
|
|
|
|
|
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
|
|
|
|
__extension__ extern int ffsll (long long int __ll)
|
|
throw () __attribute__ ((__const__));
|
|
|
|
|
|
|
|
|
|
extern int strcasecmp (const char *__s1, const char *__s2)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int strcasecmp_l (const char *__s1, const char *__s2,
|
|
__locale_t __loc)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
|
|
|
|
extern int strncasecmp_l (const char *__s1, const char *__s2,
|
|
size_t __n, __locale_t __loc)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
|
|
|
|
|
|
|
|
|
|
|
|
extern char *strsep (char **__restrict __stringp,
|
|
const char *__restrict __delim)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern char *strsignal (int __sig) throw ();
|
|
|
|
|
|
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
extern char *__stpncpy (char *__restrict __dest,
|
|
const char *__restrict __src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
extern char *stpncpy (char *__restrict __dest,
|
|
const char *__restrict __src, size_t __n)
|
|
throw () __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern int strverscmp (const char *__s1, const char *__s2)
|
|
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C++" char *basename (char *__filename)
|
|
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
|
|
extern "C++" const char *basename (const char *__filename)
|
|
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
|
|
# 642 "/usr/include/string.h" 3 4
|
|
}
|
|
# 30 "/usr/include/memory.h" 2 3 4
|
|
# 17 "include/CLog.h" 2
|
|
# 41 "include/CLog.h"
|
|
typedef enum tagLogLevel
|
|
{
|
|
FATAL = 0,
|
|
ALERT,
|
|
ERROR,
|
|
WARN,
|
|
NOTICE,
|
|
INFO,
|
|
DEBUG
|
|
} CYBERER_LOG_LEVEL_E;
|
|
# 84 "include/CLog.h"
|
|
extern void LogPrint(const int level,const char *proName,const char *func,const int line,const char *format, ...);
|
|
extern void BufPrint(const char *func,const int line, const char *pData, int iDataLen);
|
|
# 19 "include/CTypedef.h" 2
|
|
# 1 "include/CSwitchCommon.h" 1
|
|
# 13 "include/CSwitchCommon.h"
|
|
typedef enum Judge_Error_Code_E
|
|
{
|
|
JUDGE_ALL_SUCCESS=0,
|
|
JUDGE_SUCC_WITH_TWO_STAGE,
|
|
JUDGE_SUCC_WITH_MANY_STAGE,
|
|
JUDGE_SUCC_WITH_TIMEOUT,
|
|
JUDGE_SUCC_WITH_TIMEOUT_TWO_STAGE,
|
|
JUDGE_SUCC_WITH_TIMEOUT_MANY_STAGE,
|
|
|
|
JUDGE_ALL_FAIL_WITH_DIFF,
|
|
JUDGE_FAIL_WITH_TWO_STAGE,
|
|
JUDGE_FAIL_WITH_MANY_STAGE,
|
|
JUDGE_FAIL_WITH_TIMEOUT,
|
|
JUDGE_FAIL_WITH_TIMEOUT_TWO_STAGE,
|
|
JUDGE_FAIL_WITH_TIMEOUT_MANY_STAGE,
|
|
|
|
ERROR_CODE_MAX
|
|
}Judge_Error_Code_T;
|
|
|
|
typedef struct Judge_Error_Msg_S
|
|
{
|
|
Judge_Error_Code_T uiErrorCode;
|
|
# 45 "include/CSwitchCommon.h"
|
|
uint uiNosIdx;
|
|
char szReserve[32];
|
|
}Judge_Error_Msg_T;
|
|
|
|
typedef enum Judge_Sys_Info_Error_Code_E
|
|
{
|
|
JUDGE_EXCESSIVE_CPU_OCCUPY,
|
|
JUDGE_EXCESSIVE_MEM_OCCUPY,
|
|
JUDGE_EXCESSIVE_TCP_SOCKET,
|
|
JUDGE_EXCESSIVE_PROGRESS,
|
|
JUDGE_SOMEONE_BROKEN_INTO,
|
|
JUDGE_EXCEPTION_SHELL,
|
|
JUDGE_EXCEPTION_USER,
|
|
JUDGE_EXCEPTION_GROUP,
|
|
JUDGE_CHANGE_CRON,
|
|
JUDGE_CHANGE_FILE_IN_PATH,
|
|
JUDGE_CHANGE_FILE_IN_HOME,
|
|
JUDGE_EXCEPTION_APP,
|
|
JUDGE_EXCEPTION_AUTOSTART,
|
|
JUDGE_EXCEPTION_MANAGER,
|
|
JUDGE_EXCEPTION_PROTOCOL,
|
|
JUDGE_EXCEPTION_LOCAL_CONFIG_MANAGER,
|
|
JUDGE_EXCEPTION_FIREWALL,
|
|
JUDGE_TIME_OUT
|
|
}Judge_Sys_Info_Error_Code_T;
|
|
|
|
typedef struct Judge_Sys_Info_Error_Msg_S
|
|
{
|
|
Judge_Sys_Info_Error_Code_T uiErrorCode;
|
|
# 84 "include/CSwitchCommon.h"
|
|
uint uiNosIdx;
|
|
char szReserve[32];
|
|
}Judge_Sys_Info_Error_Msg_T;
|
|
|
|
typedef enum {
|
|
HB_JUDGE_E = 1,
|
|
HB_SHD_E,
|
|
HB_MYSQL_E,
|
|
HB_WEB_E,
|
|
HB_CFG_MANAGER_E,
|
|
HB_MAX_E
|
|
}HEARBEAT_E;
|
|
# 20 "include/CTypedef.h" 2
|
|
# 29 "include/CTypedef.h"
|
|
typedef socklen_t SOCKLEN_T;
|
|
typedef struct timeval TIMEVAL_T;
|
|
typedef struct sockaddr SOCKADDR_T;
|
|
typedef struct sockaddr_in SOCKADDR_IN_T;
|
|
|
|
typedef unsigned int uint;
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int uiNosIdx;
|
|
TIMEVAL_T stRcvTime;
|
|
unsigned int uiDataLen;
|
|
unsigned int uiPort;
|
|
int iCmd;
|
|
unsigned char ucData[1024];
|
|
}NosConfMsg_ST;
|
|
|
|
typedef struct
|
|
{
|
|
int iCmd;
|
|
unsigned char ucData[1024];
|
|
}ConfJudgeMsg_ST;
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int uiNosIdx;
|
|
unsigned char ucHost[16];
|
|
int iState;
|
|
}NosState_T;
|
|
|
|
typedef struct
|
|
{
|
|
uint uiType;
|
|
char szIp[32];
|
|
uint uiCpuRate;
|
|
uint uiMemRate;
|
|
uint uiTcpEstablishNum;
|
|
uint uiRunningProcessNum;
|
|
uint uiCronNum;
|
|
char szPasswdMd5[16];
|
|
}SystemState_T;
|
|
|
|
typedef struct
|
|
{
|
|
uint uiType;
|
|
char szIp[32];
|
|
uint uiProcessId;
|
|
uint uiProcessState;
|
|
}ProcessState_T;
|
|
|
|
typedef struct
|
|
{
|
|
uint uiType;
|
|
char szIp[32];
|
|
char szFileName[32];
|
|
char eventType[16];
|
|
char szFileMd5[32];
|
|
}FileState_T;
|
|
|
|
typedef struct
|
|
{
|
|
uint uiType;
|
|
char szIp[32];
|
|
char szPath[32];
|
|
char szFileName[32];
|
|
uint uiFileNum;
|
|
}FileNum_T;
|
|
|
|
typedef struct
|
|
{
|
|
uint uiType;
|
|
char szIp[32];
|
|
char szLogFile[32];
|
|
char szMsg[128];
|
|
}SysLog_T;
|
|
|
|
typedef enum MESSAGE_QUQUQ_TYPE_E{
|
|
MQT_CONFIG_E = 1,
|
|
MQT_SYSTEM_STATE_E,
|
|
MQT_PROCESS_STATE_E,
|
|
MQT_FILE_NUM_E,
|
|
MQT_FILE_STATE_E,
|
|
MQT_SYSTEM_LOG_E
|
|
}Message_QueueType_E;
|
|
# 11 "include/CMessageQueue.h" 2
|
|
# 1 "include/CJudgeUtils.h" 1
|
|
# 12 "include/CJudgeUtils.h"
|
|
# 1 "/usr/include/c++/4.8.2/cstdio" 1 3
|
|
# 39 "/usr/include/c++/4.8.2/cstdio" 3
|
|
|
|
# 40 "/usr/include/c++/4.8.2/cstdio" 3
|
|
# 94 "/usr/include/c++/4.8.2/cstdio" 3
|
|
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;
|
|
}
|
|
# 150 "/usr/include/c++/4.8.2/cstdio" 3
|
|
namespace __gnu_cxx
|
|
{
|
|
# 168 "/usr/include/c++/4.8.2/cstdio" 3
|
|
using ::snprintf;
|
|
using ::vfscanf;
|
|
using ::vscanf;
|
|
using ::vsnprintf;
|
|
using ::vsscanf;
|
|
|
|
}
|
|
|
|
namespace std
|
|
{
|
|
using ::__gnu_cxx::snprintf;
|
|
using ::__gnu_cxx::vfscanf;
|
|
using ::__gnu_cxx::vscanf;
|
|
using ::__gnu_cxx::vsnprintf;
|
|
using ::__gnu_cxx::vsscanf;
|
|
}
|
|
# 13 "include/CJudgeUtils.h" 2
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class CNonCopyable
|
|
{
|
|
protected:
|
|
CNonCopyable() {}
|
|
~CNonCopyable() {}
|
|
private:
|
|
CNonCopyable(const CNonCopyable &);
|
|
const CNonCopyable& operator=(const CNonCopyable &);
|
|
};
|
|
|
|
class CMutexLockGuard:CNonCopyable
|
|
{
|
|
public:
|
|
explicit CMutexLockGuard(pthread_mutex_t& mutex)
|
|
: m_mutex(mutex)
|
|
{
|
|
pthread_mutex_lock(&m_mutex);
|
|
}
|
|
|
|
~CMutexLockGuard()
|
|
{
|
|
pthread_mutex_unlock(&m_mutex);
|
|
}
|
|
|
|
private:
|
|
pthread_mutex_t& m_mutex;
|
|
};
|
|
|
|
template <class T>
|
|
class CSingleton
|
|
{
|
|
public:
|
|
static T* GetInstance()
|
|
{
|
|
if( _instance == __null )
|
|
{
|
|
_instance = new T;
|
|
}
|
|
return _instance;
|
|
}
|
|
|
|
static T* Instance()
|
|
{
|
|
if( _instance == __null )
|
|
{
|
|
_instance = new T;
|
|
}
|
|
return _instance;
|
|
}
|
|
|
|
static void Release()
|
|
{
|
|
if( _instance!= __null )
|
|
{
|
|
delete _instance;
|
|
}
|
|
|
|
_instance = __null;
|
|
}
|
|
|
|
protected:
|
|
CSingleton(){}
|
|
virtual ~CSingleton(){}
|
|
protected:
|
|
static T* _instance;
|
|
};
|
|
|
|
template <class T> T* CSingleton<T>::_instance=__null;
|
|
|
|
class INIReader
|
|
{
|
|
public:
|
|
explicit INIReader() {}
|
|
~INIReader() {}
|
|
|
|
|
|
|
|
|
|
|
|
int32_t Parse(const std::string& filename);
|
|
|
|
void Clear();
|
|
|
|
|
|
std::string Get(const std::string& section, const std::string& name,
|
|
const std::string& default_value);
|
|
|
|
|
|
|
|
|
|
int32_t GetInt32(const std::string& section, const std::string& name,
|
|
int32_t default_value);
|
|
|
|
uint32_t GetUInt32(const std::string& section, const std::string& name,
|
|
uint32_t default_value);
|
|
|
|
int64_t GetInt64(const std::string& section, const std::string& name,
|
|
int64_t default_value);
|
|
|
|
uint64_t GetUInt64(const std::string& section, const std::string& name,
|
|
uint64_t default_value);
|
|
|
|
|
|
|
|
|
|
double GetReal(const std::string& section, const std::string& name, double default_value);
|
|
|
|
|
|
|
|
|
|
|
|
bool GetBoolean(const std::string& section, const std::string& name, bool default_value);
|
|
|
|
|
|
|
|
const std::set<std::string>& GetSections() const;
|
|
|
|
|
|
|
|
|
|
std::set<std::string> GetFields(const std::string& section);
|
|
|
|
|
|
|
|
const char* GetLastError() const { return m_last_error; }
|
|
private:
|
|
int32_t ParseFile(FILE* file);
|
|
private:
|
|
char m_last_error[256];
|
|
std::set<std::string> m_sections;
|
|
std::map<std::string, std::map<std::string, std::string> > m_fields;
|
|
};
|
|
# 12 "include/CMessageQueue.h" 2
|
|
|
|
template <typename T>
|
|
class CMessageQueue : public CSingleton<CMessageQueue<T> >
|
|
{
|
|
public:
|
|
CMessageQueue();
|
|
~CMessageQueue();
|
|
|
|
void push(T stData,Message_QueueType_E MessageType);
|
|
void pop(Message_QueueType_E MessageType);
|
|
T& front(Message_QueueType_E MessageType);
|
|
T& back(Message_QueueType_E MessageType);
|
|
int empty(Message_QueueType_E MessageType);
|
|
int size(Message_QueueType_E MessageType);
|
|
void remove(T stData, Message_QueueType_E MessageType);
|
|
|
|
private:
|
|
|
|
|
|
private:
|
|
static const Message_QueueType_E m_MessageTypeE = MQT_CONFIG_E;
|
|
|
|
pthread_mutex_t m_QueueMutex;
|
|
std::list<T> m_queue;
|
|
|
|
pthread_mutex_t ss_QueueMutex;
|
|
std::list<T> q_SysState;
|
|
|
|
pthread_mutex_t ps_QueueMutex;
|
|
std::list<T> q_ProcessState;
|
|
|
|
pthread_mutex_t fs_QueueMutex;
|
|
std::list<T> q_FileState;
|
|
|
|
pthread_mutex_t fn_QueueMutex;
|
|
std::list<T> q_FileNum;
|
|
|
|
pthread_mutex_t sl_QueueMutex;
|
|
std::list<T> q_SysLog;
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
CMessageQueue<T>::CMessageQueue()
|
|
{
|
|
pthread_mutex_init(&m_QueueMutex, __null);
|
|
|
|
pthread_mutex_init(&ss_QueueMutex, __null);
|
|
pthread_mutex_init(&ps_QueueMutex, __null);
|
|
pthread_mutex_init(&fs_QueueMutex, __null);
|
|
pthread_mutex_init(&fn_QueueMutex, __null);
|
|
pthread_mutex_init(&sl_QueueMutex, __null);
|
|
}
|
|
|
|
template <typename T>
|
|
CMessageQueue<T>::~CMessageQueue()
|
|
{
|
|
pthread_mutex_destroy(&m_QueueMutex);
|
|
|
|
pthread_mutex_destroy(&ss_QueueMutex);
|
|
pthread_mutex_destroy(&ps_QueueMutex);
|
|
pthread_mutex_destroy(&fs_QueueMutex);
|
|
pthread_mutex_destroy(&fn_QueueMutex);
|
|
pthread_mutex_destroy(&sl_QueueMutex);
|
|
}
|
|
|
|
template <typename T>
|
|
void CMessageQueue<T>::push(T stData,Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
switch(MessageType)
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case MQT_CONFIG_E: { CMutexLockGuard m_MutexLock(m_QueueMutex); m_queue.push_back(stData); break; };
|
|
case MQT_SYSTEM_STATE_E: { CMutexLockGuard m_MutexLock(ss_QueueMutex); q_SysState.push_back(stData); break; };
|
|
case MQT_PROCESS_STATE_E: { CMutexLockGuard m_MutexLock(ps_QueueMutex); q_ProcessState.push_back(stData); break; };
|
|
case MQT_FILE_STATE_E: { CMutexLockGuard m_MutexLock(fs_QueueMutex); q_FileState.push_back(stData); break; };
|
|
case MQT_FILE_NUM_E: { CMutexLockGuard m_MutexLock(fn_QueueMutex); q_FileNum.push_back(stData); break; };
|
|
case MQT_SYSTEM_LOG_E: { CMutexLockGuard m_MutexLock(sl_QueueMutex); q_SysLog.push_back(stData); break; };
|
|
# 136 "include/CMessageQueue.h"
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
void CMessageQueue<T>::pop(Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
switch(MessageType)
|
|
{
|
|
case MQT_CONFIG_E:
|
|
{
|
|
CMutexLockGuard m_MutexLock(m_QueueMutex);
|
|
m_queue.pop_front();
|
|
break;
|
|
}
|
|
case MQT_SYSTEM_STATE_E:
|
|
{
|
|
CMutexLockGuard ss_MutexLock(ss_QueueMutex);
|
|
q_SysState.pop_front();
|
|
break;
|
|
}
|
|
|
|
case MQT_PROCESS_STATE_E:
|
|
{
|
|
CMutexLockGuard ps_MutexLock(ps_QueueMutex);
|
|
q_ProcessState.pop_front();
|
|
break;
|
|
}
|
|
|
|
case MQT_FILE_STATE_E:
|
|
{
|
|
CMutexLockGuard fs_MutexLock(fs_QueueMutex);
|
|
q_FileState.pop_front();
|
|
break;
|
|
}
|
|
case MQT_FILE_NUM_E:
|
|
{
|
|
CMutexLockGuard fn_MutexLock(fn_QueueMutex);
|
|
q_FileNum.pop_front();
|
|
break;
|
|
}
|
|
case MQT_SYSTEM_LOG_E:
|
|
{
|
|
CMutexLockGuard sl_MutexLock(sl_QueueMutex);
|
|
q_SysLog.pop_front();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
T& CMessageQueue<T>::front(Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
|
|
switch(MessageType)
|
|
{
|
|
case MQT_CONFIG_E:
|
|
{
|
|
CMutexLockGuard m_MutexLock(m_QueueMutex);
|
|
return m_queue.front();
|
|
}
|
|
case MQT_SYSTEM_STATE_E:
|
|
{
|
|
CMutexLockGuard ss_MutexLock(ss_QueueMutex);
|
|
return q_SysState.front();
|
|
}
|
|
case MQT_PROCESS_STATE_E:
|
|
{
|
|
CMutexLockGuard ps_MutexLock(ps_QueueMutex);
|
|
return q_ProcessState.front();
|
|
}
|
|
case MQT_FILE_STATE_E:
|
|
{
|
|
CMutexLockGuard fs_MutexLock(fs_QueueMutex);
|
|
return q_FileState.front();
|
|
}
|
|
case MQT_FILE_NUM_E:
|
|
{
|
|
CMutexLockGuard fn_MutexLock(fn_QueueMutex);
|
|
return q_FileNum.front();
|
|
}
|
|
case MQT_SYSTEM_LOG_E:
|
|
{
|
|
CMutexLockGuard sl_MutexLock(sl_QueueMutex);
|
|
return q_SysLog.front();
|
|
}
|
|
default:
|
|
return m_queue.front();
|
|
}
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
T& CMessageQueue<T>::back(Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
switch(MessageType)
|
|
{
|
|
case MQT_CONFIG_E:
|
|
{
|
|
CMutexLockGuard m_MutexLock(m_QueueMutex);
|
|
return m_queue.back();
|
|
}
|
|
case MQT_SYSTEM_STATE_E:
|
|
{
|
|
CMutexLockGuard ss_MutexLock(ss_QueueMutex);
|
|
return q_SysState.back();
|
|
}
|
|
case MQT_PROCESS_STATE_E:
|
|
{
|
|
CMutexLockGuard ps_MutexLock(ps_QueueMutex);
|
|
return q_ProcessState.back();
|
|
}
|
|
case MQT_FILE_STATE_E:
|
|
{
|
|
CMutexLockGuard fs_MutexLock(fs_QueueMutex);
|
|
return q_FileState.back();
|
|
}
|
|
case MQT_FILE_NUM_E:
|
|
{
|
|
CMutexLockGuard fn_MutexLock(fn_QueueMutex);
|
|
return q_FileNum.back();
|
|
}
|
|
case MQT_SYSTEM_LOG_E:
|
|
{
|
|
CMutexLockGuard sl_MutexLock(sl_QueueMutex);
|
|
return q_SysLog.back();
|
|
}
|
|
default:
|
|
return m_queue.back();
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
int CMessageQueue<T>::empty(Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
switch(MessageType)
|
|
{
|
|
case MQT_CONFIG_E:
|
|
{
|
|
CMutexLockGuard m_MutexLock(m_QueueMutex);
|
|
return m_queue.empty();
|
|
}
|
|
case MQT_SYSTEM_STATE_E:
|
|
{
|
|
CMutexLockGuard ss_MutexLock(ss_QueueMutex);
|
|
return q_SysState.empty();
|
|
}
|
|
case MQT_PROCESS_STATE_E:
|
|
{
|
|
CMutexLockGuard ps_MutexLock(ps_QueueMutex);
|
|
return q_ProcessState.empty();
|
|
}
|
|
case MQT_FILE_STATE_E:
|
|
{
|
|
CMutexLockGuard fs_MutexLock(fs_QueueMutex);
|
|
return q_FileState.empty();
|
|
}
|
|
case MQT_FILE_NUM_E:
|
|
{
|
|
CMutexLockGuard fn_MutexLock(fn_QueueMutex);
|
|
return q_FileNum.empty();
|
|
}
|
|
case MQT_SYSTEM_LOG_E:
|
|
{
|
|
CMutexLockGuard sl_MutexLock(sl_QueueMutex);
|
|
return q_SysLog.empty();
|
|
}
|
|
default:
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
template <typename T>
|
|
int CMessageQueue<T>::size(Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
|
|
switch(MessageType)
|
|
{
|
|
case MQT_CONFIG_E:
|
|
{
|
|
CMutexLockGuard MutexLock(m_QueueMutex);
|
|
return m_queue.size();
|
|
}
|
|
case MQT_SYSTEM_STATE_E:
|
|
{
|
|
CMutexLockGuard MutexLock(ss_QueueMutex);
|
|
return q_SysState.size();
|
|
}
|
|
case MQT_PROCESS_STATE_E:
|
|
{
|
|
CMutexLockGuard MutexLock(ps_QueueMutex);
|
|
return q_ProcessState.size();
|
|
}
|
|
case MQT_FILE_STATE_E:
|
|
{
|
|
CMutexLockGuard MutexLock(fs_QueueMutex);
|
|
return q_FileState.size();
|
|
}
|
|
case MQT_FILE_NUM_E:
|
|
{
|
|
CMutexLockGuard MutexLock(fn_QueueMutex);
|
|
return q_FileNum.size();
|
|
}
|
|
case MQT_SYSTEM_LOG_E:
|
|
{
|
|
CMutexLockGuard MutexLock(sl_QueueMutex);
|
|
return q_SysLog.size();
|
|
}
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
void CMessageQueue<T>::remove(T stData, Message_QueueType_E MessageType = m_MessageTypeE)
|
|
{
|
|
|
|
switch(MessageType)
|
|
{
|
|
case MQT_CONFIG_E:
|
|
{
|
|
CMutexLockGuard MutexLock(m_QueueMutex);
|
|
m_queue.remove(stData);
|
|
break;
|
|
}
|
|
case MQT_SYSTEM_STATE_E:
|
|
{
|
|
CMutexLockGuard MutexLock(ss_QueueMutex);
|
|
q_SysState.remove(stData);
|
|
break;
|
|
}
|
|
case MQT_PROCESS_STATE_E:
|
|
{
|
|
CMutexLockGuard MutexLock(ps_QueueMutex);
|
|
q_ProcessState.remove(stData);
|
|
break;
|
|
}
|
|
case MQT_FILE_STATE_E:
|
|
{
|
|
CMutexLockGuard MutexLock(fs_QueueMutex);
|
|
q_FileState.remove(stData);
|
|
break;
|
|
}
|
|
case MQT_FILE_NUM_E:
|
|
{
|
|
CMutexLockGuard MutexLock(fn_QueueMutex);
|
|
q_FileNum.remove(stData);
|
|
break;
|
|
}
|
|
case MQT_SYSTEM_LOG_E:
|
|
{
|
|
CMutexLockGuard MutexLock(sl_QueueMutex);
|
|
q_SysLog.remove(stData);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
# 10 "test.cpp" 2
|
|
# 1 "include/CTypedef.h" 1
|
|
# 11 "test.cpp" 2
|
|
# 1 "include/CLog.h" 1
|
|
# 12 "test.cpp" 2
|
|
|
|
|
|
using std::cout;
|
|
using std::endl;
|
|
|
|
void check()
|
|
{
|
|
cout << endl << "------------------ Check Message Queue--------------------" << endl;
|
|
cout << " ------- M_MessageQueue ------- " << endl;
|
|
cout << "队列空: " << CMessageQueue<int>::Instance()->empty() << " ,"
|
|
<< "长度: " << CMessageQueue<int>::Instance()->size() << " ,"
|
|
<< "队头: " << CMessageQueue<int>::Instance()->front() << " ,"
|
|
<< "队尾: " << CMessageQueue<int>::Instance()->back() << endl;
|
|
cout << " ------ MQT_SYSTEM_STATE_E ------ " << endl;
|
|
cout << "队列空: " << CMessageQueue<int>::Instance()->empty(MQT_SYSTEM_STATE_E) << " ,"
|
|
<< "长度: " << CMessageQueue<int>::Instance()->size(MQT_SYSTEM_STATE_E) << " ,"
|
|
<< "队头: " << CMessageQueue<int>::Instance()->front(MQT_SYSTEM_STATE_E) << " ,"
|
|
<< "队尾: " << CMessageQueue<int>::Instance()->back(MQT_SYSTEM_STATE_E) << endl;
|
|
cout << " ----- MQT_PROCESS_STATE_E ------ " << endl;
|
|
cout << "队列空: " << CMessageQueue<int>::Instance()->empty(MQT_PROCESS_STATE_E) << " ,"
|
|
<< "长度: " << CMessageQueue<int>::Instance()->size(MQT_PROCESS_STATE_E) << " ,"
|
|
<< "队头: " << CMessageQueue<int>::Instance()->front(MQT_PROCESS_STATE_E) << " ,"
|
|
<< "队尾: " << CMessageQueue<int>::Instance()->back(MQT_PROCESS_STATE_E) << endl;
|
|
cout << " ------- MQT_FILE_STATE_E ------- " << endl;
|
|
cout << "队列空: " << CMessageQueue<int>::Instance()->empty(MQT_FILE_STATE_E) << " ,"
|
|
<< "长度: " << CMessageQueue<int>::Instance()->size(MQT_FILE_STATE_E) << " ,"
|
|
<< "队头: " << CMessageQueue<int>::Instance()->front(MQT_FILE_STATE_E) << " ,"
|
|
<< "队尾: " << CMessageQueue<int>::Instance()->back(MQT_FILE_STATE_E) << endl;
|
|
cout << " -------- MQT_FILE_NUM_E -------- " << endl ;
|
|
cout << "队列空: " << CMessageQueue<int>::Instance()->empty(MQT_FILE_NUM_E) << " ,"
|
|
<< "长度: " << CMessageQueue<int>::Instance()->size(MQT_FILE_NUM_E) << " ,"
|
|
<< "队头: " << CMessageQueue<int>::Instance()->front(MQT_FILE_NUM_E) << " ,"
|
|
<< "队尾: " << CMessageQueue<int>::Instance()->back(MQT_FILE_NUM_E) << endl;
|
|
|
|
cout << " ------ MQT_SYSTEM_LOG_E ------ " << endl;
|
|
cout << "队列空: " << CMessageQueue<int>::Instance()->empty(MQT_SYSTEM_LOG_E) << " ,"
|
|
<< "长度: " << CMessageQueue<int>::Instance()->size(MQT_SYSTEM_LOG_E) << " ,"
|
|
<< "队头: " << CMessageQueue<int>::Instance()->front(MQT_SYSTEM_LOG_E) << " ,"
|
|
<< "队尾: " << CMessageQueue<int>::Instance()->back(MQT_SYSTEM_LOG_E) << endl;
|
|
cout << endl << "------------------------- FINISH -------------------------" << endl;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
cout << "step1: 默认队列入队3元素: 1 2 3" << endl;
|
|
for(int i=1;i<4;i++)
|
|
{
|
|
CMessageQueue<int>::Instance()->push(i);
|
|
}
|
|
check();
|
|
|
|
cout << "step2: MQT_SYSTEM_STATE_E 队列入队3元素: 1 2 3" << endl;
|
|
for(int i=1;i<4;i++)
|
|
{
|
|
CMessageQueue<int>::Instance()->push(i,MQT_SYSTEM_STATE_E);
|
|
}
|
|
check();
|
|
|
|
cout << "step3: MQT_PROCESS_STATE_E 队列入队3元素: 1 2 3" << endl;
|
|
for(int i=1;i<4;i++)
|
|
{
|
|
CMessageQueue<int>::Instance()->push(i, MQT_PROCESS_STATE_E);
|
|
}
|
|
check();
|
|
|
|
cout << "step4: MQT_FILE_STATE_E 队列入队3元素: 1 2 3" << endl;
|
|
for(int i=1;i<4;i++)
|
|
{
|
|
CMessageQueue<int>::Instance()->push(i, MQT_FILE_STATE_E);
|
|
}
|
|
check();
|
|
|
|
cout << "step5: MQT_FILE_NUM_E 队列入队3元素: 1 2 3" << endl;
|
|
for(int i=1;i<4;i++)
|
|
{
|
|
CMessageQueue<int>::Instance()->push(i, MQT_FILE_NUM_E);
|
|
}
|
|
check();
|
|
|
|
cout << "step6: MQT_SYSTEM_LOG_E 队列入队3元素: 1 2 3" << endl;
|
|
for(int i=1;i<4;i++)
|
|
{
|
|
CMessageQueue<int>::Instance()->push(i, MQT_SYSTEM_LOG_E);
|
|
sleep(1);
|
|
}
|
|
check();
|
|
|
|
|
|
return 0;
|
|
}
|