Attachment 150343 Details for Bug 232856 – Preprocessed source stored into /tmp/ccTnUUOo.out file, please attach this to your bugreport.

Preprocessed source stored into /tmp/ccTnUUOo.out file, please attach this to your bugreport.

ccPLfnm2.out (text/plain), 1.48 MB, created by Paul McQuesten on 2007-03-18 23:55:32 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Paul McQuesten

Created: 2007-03-18 23:55:32 UTC

Size: 1.48 MB

patch

obsolete

>// /usr/libexec/gcc/i386-redhat-linux/3.4.4/cc1plus -quiet -D_GNU_SOURCE -DDEBUG apFact.cpp -quiet -dumpbase apFact.cpp -auxbase apFact -g -o - -frandom-seed=0
># 1 "apFact.cpp"
># 1 "/home/paulmcq/c/ai/bot/carter//"
># 1 "<built-in>"
># 1 "<command line>"
># 1 "apFact.cpp"
>
>
>
># 1 "aiLex.h" 1
># 29 "aiLex.h"
># 1 "/usr/include/sys/stat.h" 1 3 4
># 26 "/usr/include/sys/stat.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 314 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 315 "/usr/include/features.h" 2 3 4
># 337 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
># 338 "/usr/include/features.h" 2 3 4
># 27 "/usr/include/sys/stat.h" 2 3 4
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/types.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 213 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 32 "/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;
>
>
>
>
>__extension__ typedef signed long long int __int64_t;
>__extension__ typedef unsigned long long int __uint64_t;
>
>
>
>
>
>
>
>__extension__ typedef long long int __quad_t;
>__extension__ typedef unsigned long long int __u_quad_t;
># 129 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 130 "/usr/include/bits/types.h" 2 3 4
>
>
>
>
>
>
>__extension__ typedef __u_quad_t __dev_t;
>__extension__ typedef unsigned int __uid_t;
>__extension__ typedef unsigned int __gid_t;
>__extension__ typedef unsigned long int __ino_t;
>__extension__ typedef __u_quad_t __ino64_t;
>__extension__ typedef unsigned int __mode_t;
>__extension__ typedef unsigned int __nlink_t;
>__extension__ typedef long int __off_t;
>__extension__ typedef __quad_t __off64_t;
>__extension__ typedef int __pid_t;
>__extension__ typedef struct { int __val[2]; } __fsid_t;
>__extension__ typedef long int __clock_t;
>__extension__ typedef unsigned long int __rlim_t;
>__extension__ typedef __u_quad_t __rlim64_t;
>__extension__ typedef unsigned int __id_t;
>__extension__ typedef long int __time_t;
>__extension__ typedef unsigned int __useconds_t;
>__extension__ typedef long int __suseconds_t;
>
>__extension__ typedef int __daddr_t;
>__extension__ typedef long int __swblk_t;
>__extension__ typedef int __key_t;
>
>
>__extension__ typedef int __clockid_t;
>
>
>__extension__ typedef int __timer_t;
>
>
>__extension__ typedef long int __blksize_t;
>
>
>
>
>__extension__ typedef long int __blkcnt_t;
>__extension__ typedef __quad_t __blkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsblkcnt_t;
>__extension__ typedef __u_quad_t __fsblkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsfilcnt_t;
>__extension__ typedef __u_quad_t __fsfilcnt64_t;
>
>__extension__ typedef int __ssize_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>__extension__ typedef int __intptr_t;
>
>
>__extension__ typedef unsigned int __socklen_t;
># 29 "/usr/include/sys/stat.h" 2 3 4
># 37 "/usr/include/sys/stat.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 74 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 118 "/usr/include/time.h" 3 4
>struct timespec
> {
> __time_t tv_sec;
> long int tv_nsec;
> };
># 38 "/usr/include/sys/stat.h" 2 3 4
>
>
>
>
>
>
>typedef __dev_t dev_t;
>
>
>
>
>typedef __gid_t gid_t;
>
>
>
>
>
>typedef __ino_t ino_t;
>
>
>
>
>
>
>
>typedef __mode_t mode_t;
>
>
>
>
>typedef __nlink_t nlink_t;
>
>
>
>
>
>typedef __off_t off_t;
>
>
>
>
>
>
>
>typedef __uid_t uid_t;
>
>
>
>
>
>
>
>typedef __blkcnt_t blkcnt_t;
>
>
>
>
>
>
>
>typedef __blksize_t blksize_t;
>
>
>
>
>extern "C" {
>
># 1 "/usr/include/bits/stat.h" 1 3 4
># 36 "/usr/include/bits/stat.h" 3 4
>struct stat
> {
> __dev_t st_dev;
> unsigned short int __pad1;
>
> __ino_t st_ino;
>
>
>
> __mode_t st_mode;
> __nlink_t st_nlink;
> __uid_t st_uid;
> __gid_t st_gid;
> __dev_t st_rdev;
> unsigned short int __pad2;
>
> __off_t st_size;
>
>
>
> __blksize_t st_blksize;
>
>
> __blkcnt_t st_blocks;
># 70 "/usr/include/bits/stat.h" 3 4
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
># 85 "/usr/include/bits/stat.h" 3 4
> unsigned long int __unused4;
> unsigned long int __unused5;
>
>
>
> };
>
>
>struct stat64
> {
> __dev_t st_dev;
> unsigned int __pad1;
>
> __ino_t __st_ino;
> __mode_t st_mode;
> __nlink_t st_nlink;
> __uid_t st_uid;
> __gid_t st_gid;
> __dev_t st_rdev;
> unsigned int __pad2;
> __off64_t st_size;
> __blksize_t st_blksize;
>
> __blkcnt64_t st_blocks;
>
>
>
>
>
>
>
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
># 127 "/usr/include/bits/stat.h" 3 4
> __ino64_t st_ino;
> };
># 106 "/usr/include/sys/stat.h" 2 3 4
># 207 "/usr/include/sys/stat.h" 3 4
>extern int stat (__const char *__restrict __file,
> struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
># 226 "/usr/include/sys/stat.h" 3 4
>extern int stat64 (__const char *__restrict __file,
> struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int lstat (__const char *__restrict __file,
> struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
># 248 "/usr/include/sys/stat.h" 3 4
>extern int lstat64 (__const char *__restrict __file,
> struct stat64 *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int chmod (__const char *__file, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int lchmod (__const char *__file, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fchmod (int __fd, __mode_t __mode) throw ();
>
>
>
>
>
>extern __mode_t umask (__mode_t __mask) throw ();
>
>
>
>
>extern __mode_t getumask (void) throw ();
>
>
>
>extern int mkdir (__const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int mkfifo (__const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
># 324 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
> throw () __attribute__ ((__nonnull__ (3)));
>extern int __xstat (int __ver, __const char *__filename,
> struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat (int __ver, __const char *__filename,
> struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
># 350 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
> throw () __attribute__ ((__nonnull__ (3)));
>extern int __xstat64 (int __ver, __const char *__filename,
> struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat64 (int __ver, __const char *__filename,
> struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>
>extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
> __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>extern __inline__ int
>stat (__const char *__path, struct stat *__statbuf) throw ()
>{
> return __xstat (3, __path, __statbuf);
>}
>
>
>extern __inline__ int
>lstat (__const char *__path, struct stat *__statbuf) throw ()
>{
> return __lxstat (3, __path, __statbuf);
>}
>
>
>extern __inline__ int
>fstat (int __fd, struct stat *__statbuf) throw ()
>{
> return __fxstat (3, __fd, __statbuf);
>}
>
>
>extern __inline__ int
>mknod (__const char *__path, __mode_t __mode, __dev_t __dev) throw ()
>{
> return __xmknod (1, __path, __mode, &__dev);
>}
>
>
>
>
>
>extern __inline__ int
>stat64 (__const char *__path, struct stat64 *__statbuf) throw ()
>{
> return __xstat64 (3, __path, __statbuf);
>}
>
>
>extern __inline__ int
>lstat64 (__const char *__path, struct stat64 *__statbuf) throw ()
>{
> return __lxstat64 (3, __path, __statbuf);
>}
>
>
>extern __inline__ int
>fstat64 (int __fd, struct stat64 *__statbuf) throw ()
>{
> return __fxstat64 (3, __fd, __statbuf);
>}
>
>
>
>
>}
># 30 "aiLex.h" 2
># 1 "/usr/include/unistd.h" 1 3 4
># 28 "/usr/include/unistd.h" 3 4
>extern "C" {
># 171 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 172 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 176 "/usr/include/unistd.h" 2 3 4
># 189 "/usr/include/unistd.h" 3 4
>typedef __ssize_t ssize_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 196 "/usr/include/unistd.h" 2 3 4
># 219 "/usr/include/unistd.h" 3 4
>typedef __off64_t off64_t;
>
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>
>
>typedef __intptr_t intptr_t;
>
>
>
>
>
>
>typedef __socklen_t socklen_t;
># 256 "/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)));
># 287 "/usr/include/unistd.h" 3 4
>extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
># 298 "/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);
># 328 "/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);
># 356 "/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 ();
># 378 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) throw ();
># 390 "/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);
># 414 "/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 chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int fchdir (int __fd) throw ();
># 448 "/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)));
>
>
>
>
>extern int dup (int __fd) throw ();
>
>
>extern int dup2 (int __fd, int __fd2) throw ();
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (__const char *__path, char *__const __argv[],
> char *__const __envp[]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
> throw ();
>
>
>
>
>extern int execv (__const char *__path, char *__const __argv[])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execle (__const char *__path, __const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execl (__const char *__path, __const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int execvp (__const char *__file, char *__const __argv[])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int execlp (__const char *__file, __const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int nice (int __inc) throw ();
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 26 "/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
>
> };
>
>
>enum
> {
> _CS_PATH,
>
>
> _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
> _CS_GNU_LIBC_VERSION,
>
> _CS_GNU_LIBPTHREAD_VERSION,
>
>
> _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
>
> };
># 531 "/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 () __attribute__ ((__const__));
>
>
>
>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 ();
># 567 "/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 ();
># 593 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) throw ();
># 610 "/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 *__euid, __uid_t *__ruid, __uid_t *__suid);
>
>
>
>extern int getresgid (__gid_t *__egid, __gid_t *__rgid, __gid_t *__sgid);
>
>
>
>extern int setresuid (__uid_t __euid, __uid_t __ruid, __uid_t __suid);
>
>
>
>extern int setresgid (__gid_t __egid, __gid_t __rgid, __gid_t __sgid);
>
>
>
>
>
>
>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 symlink (__const char *__from, __const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int readlink (__const char *__restrict __path, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>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)));
># 783 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/getopt.h" 1 3 4
># 50 "/usr/include/getopt.h" 3 4
>extern "C" {
># 59 "/usr/include/getopt.h" 3 4
>extern char *optarg;
># 73 "/usr/include/getopt.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 152 "/usr/include/getopt.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
> throw ();
># 171 "/usr/include/getopt.h" 3 4
>}
># 784 "/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)));
># 869 "/usr/include/unistd.h" 3 4
>extern int fsync (int __fd);
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) throw ();
>
>
>
>
>extern int getpagesize (void) throw () __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) throw ();
>
>
>
>
>extern int truncate (__const char *__file, __off_t __length)
> throw () __attribute__ ((__nonnull__ (1)));
># 906 "/usr/include/unistd.h" 3 4
>extern int truncate64 (__const char *__file, __off64_t __length)
> throw () __attribute__ ((__nonnull__ (1)));
># 916 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off_t __length) throw ();
># 926 "/usr/include/unistd.h" 3 4
>extern int ftruncate64 (int __fd, __off64_t __length) throw ();
># 936 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) throw ();
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) throw ();
># 957 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) throw ();
># 980 "/usr/include/unistd.h" 3 4
>extern int lockf (int __fd, int __cmd, __off_t __len);
># 990 "/usr/include/unistd.h" 3 4
>extern int lockf64 (int __fd, int __cmd, __off64_t __len);
># 1011 "/usr/include/unistd.h" 3 4
>extern int fdatasync (int __fildes) throw ();
>
>
>
>
>
>
>
>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)));
>
>
>
>
>
>
>
>extern char *ctermid (char *__s) throw () __attribute__ ((__nonnull__ (1)));
>
>
>}
># 31 "aiLex.h" 2
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++config.h" 1 3
># 35 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++config.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/os_defines.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++config.h" 2 3
># 57 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++config.h" 3
>namespace __gnu_debug_def { }
>
>namespace __gnu_debug
>{
> using namespace __gnu_debug_def;
>}
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstddef" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstddef" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstddef" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 151 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstddef" 2 3
>
>namespace std
>{
> using ::ptrdiff_t;
> using ::size_t;
>}
># 51 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 2 3
>
># 1 "/usr/include/stdio.h" 1 3 4
># 30 "/usr/include/stdio.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 35 "/usr/include/stdio.h" 2 3 4
># 44 "/usr/include/stdio.h" 3 4
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 62 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 72 "/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
># 14 "/usr/include/_G_config.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 354 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 15 "/usr/include/_G_config.h" 2 3 4
># 24 "/usr/include/_G_config.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 48 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
>
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 51 "/usr/include/wchar.h" 2 3 4
># 76 "/usr/include/wchar.h" 3 4
>typedef struct
>{
> int __count;
> union
> {
> wint_t __wch;
> char __wchb[4];
> } __value;
>} __mbstate_t;
># 25 "/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;
># 44 "/usr/include/_G_config.h" 3 4
># 1 "/usr/include/gconv.h" 1 3 4
># 28 "/usr/include/gconv.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 48 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
># 29 "/usr/include/gconv.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 32 "/usr/include/gconv.h" 2 3 4
>
>
>
>
>
>enum
>{
> __GCONV_OK = 0,
> __GCONV_NOCONV,
> __GCONV_NODB,
> __GCONV_NOMEM,
>
> __GCONV_EMPTY_INPUT,
> __GCONV_FULL_OUTPUT,
> __GCONV_ILLEGAL_INPUT,
> __GCONV_INCOMPLETE_INPUT,
>
> __GCONV_ILLEGAL_DESCRIPTOR,
> __GCONV_INTERNAL_ERROR
>};
>
>
>
>enum
>{
> __GCONV_IS_LAST = 0x0001,
> __GCONV_IGNORE_ERRORS = 0x0002
>};
>
>
>
>struct __gconv_step;
>struct __gconv_step_data;
>struct __gconv_loaded_object;
>struct __gconv_trans_data;
>
>
>
>typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
> __const unsigned char **, __const unsigned char *,
> unsigned char **, size_t *, int, int);
>
>
>typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);
>
>
>typedef int (*__gconv_init_fct) (struct __gconv_step *);
>typedef void (*__gconv_end_fct) (struct __gconv_step *);
>
>
>
>typedef int (*__gconv_trans_fct) (struct __gconv_step *,
> struct __gconv_step_data *, void *,
> __const unsigned char *,
> __const unsigned char **,
> __const unsigned char *, unsigned char **,
> size_t *);
>
>
>typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
> __const unsigned char *,
> unsigned char *, unsigned char *);
>
>
>typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
> size_t *);
>
>
>typedef int (*__gconv_trans_init_fct) (void **, const char *);
>typedef void (*__gconv_trans_end_fct) (void *);
>
>struct __gconv_trans_data
>{
>
> __gconv_trans_fct __trans_fct;
> __gconv_trans_context_fct __trans_context_fct;
> __gconv_trans_end_fct __trans_end_fct;
> void *__data;
> struct __gconv_trans_data *__next;
>};
>
>
>
>struct __gconv_step
>{
> struct __gconv_loaded_object *__shlib_handle;
> __const char *__modname;
>
> int __counter;
>
> char *__from_name;
> char *__to_name;
>
> __gconv_fct __fct;
> __gconv_btowc_fct __btowc_fct;
> __gconv_init_fct __init_fct;
> __gconv_end_fct __end_fct;
>
>
>
> int __min_needed_from;
> int __max_needed_from;
> int __min_needed_to;
> int __max_needed_to;
>
>
> int __stateful;
>
> void *__data;
>};
>
>
>
>struct __gconv_step_data
>{
> unsigned char *__outbuf;
> unsigned char *__outbufend;
>
>
>
> int __flags;
>
>
>
> int __invocation_counter;
>
>
>
> int __internal_use;
>
> __mbstate_t *__statep;
> __mbstate_t __state;
>
>
>
> struct __gconv_trans_data *__trans;
>};
>
>
>
>typedef struct __gconv_info
>{
> size_t __nsteps;
> struct __gconv_step *__steps;
> __extension__ struct __gconv_step_data __data [];
>} *__gconv_t;
># 45 "/usr/include/_G_config.h" 2 3 4
>typedef union
>{
> struct __gconv_info __cd;
> struct
> {
> struct __gconv_info __cd;
> struct __gconv_step_data __data;
> } __combined;
>} _G_iconv_t;
>
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 166 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 176 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
> struct _IO_marker *_next;
> struct _IO_FILE *_sbuf;
>
>
>
> int _pos;
># 199 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
> __codecvt_ok,
> __codecvt_partial,
> __codecvt_error,
> __codecvt_noconv
>};
># 267 "/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;
># 315 "/usr/include/libio.h" 3 4
> __off64_t _offset;
>
>
>
>
>
> void *__pad1;
> void *__pad2;
>
> int _mode;
>
> char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];
>
>};
>
>
>
>
>
>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_;
># 354 "/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 *) throw ();
>extern int __uflow (_IO_FILE *) throw ();
>extern int __overflow (_IO_FILE *, int) throw ();
>extern wint_t __wunderflow (_IO_FILE *) throw ();
>extern wint_t __wuflow (_IO_FILE *) throw ();
>extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();
># 444 "/usr/include/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp) throw ();
>extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
>extern int _IO_feof (_IO_FILE *__fp) throw ();
>extern int _IO_ferror (_IO_FILE *__fp) throw ();
>
>extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) throw ();
>extern void _IO_funlockfile (_IO_FILE *) throw ();
>extern int _IO_ftrylockfile (_IO_FILE *) throw ();
># 474 "/usr/include/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
> __gnuc_va_list, int *__restrict) throw ();
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
> __gnuc_va_list) throw ();
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();
>
>extern void _IO_free_backup_area (_IO_FILE *) throw ();
># 532 "/usr/include/libio.h" 3 4
>}
># 73 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 86 "/usr/include/stdio.h" 3 4
>
>
>typedef _G_fpos_t fpos_t;
>
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 138 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 139 "/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 FILE *tmpfile (void);
># 176 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void);
>
>
>
>extern char *tmpnam (char *__s) throw ();
>
>
>
>
>
>extern char *tmpnam_r (char *__s) throw ();
># 198 "/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);
>
># 223 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 233 "/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);
># 264 "/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 **__restrict __bufloc,
> size_t *__restrict __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 ();
>
>
>
>
>
>
>
>
>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)));
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 456 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 467 "/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);
>
># 500 "/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);
>
>
>
>
>
>
>extern char *gets (char *__s);
>
># 545 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
> FILE *__restrict __stream);
># 561 "/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);
>
># 622 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (__const char *__restrict __s,
> FILE *__restrict __stream);
># 633 "/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);
>
># 669 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream);
># 688 "/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);
># 711 "/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
># 27 "/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[];
># 750 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) throw ();
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) throw ();
># 769 "/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 ();
># 836 "/usr/include/stdio.h" 3 4
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 2 3
># 97 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>}
># 153 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdio" 3
>namespace __gnu_cxx
>{
># 167 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>}
># 36 "aiLex.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstring" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstring" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstring" 3
>
>
>
># 1 "/usr/include/string.h" 1 3 4
># 28 "/usr/include/string.h" 3 4
>extern "C" {
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 34 "/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 void *memchr (__const void *__s, int __c, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern void *rawmemchr (__const void *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memrchr (__const void *__s, int __c, size_t __n)
> throw () __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)));
>
>
>
>
>
>
># 1 "/usr/include/xlocale.h" 1 3 4
># 28 "/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;
># 119 "/usr/include/string.h" 2 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)));
># 165 "/usr/include/string.h" 3 4
>
>
>extern char *strchr (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>extern char *strrchr (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern char *strchrnul (__const char *__s, int __c)
> throw () __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 char *strpbrk (__const char *__s, __const char *__accept)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strstr (__const char *__haystack, __const char *__needle)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>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 char *strcasestr (__const char *__haystack, __const char *__needle)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>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 ();
>
># 281 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>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 char *index (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern char *rindex (__const char *__s, int __c)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>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 int strverscmp (__const char *__s1, __const char *__s2)
> throw () __attribute__ ((__pure__)) __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 char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
># 426 "/usr/include/string.h" 3 4
>}
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstring" 2 3
># 77 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstring" 3
>namespace std
>{
> using ::memcpy;
> using ::memmove;
> using ::strcpy;
> using ::strncpy;
> using ::strcat;
> using ::strncat;
> using ::memcmp;
> using ::strcmp;
> using ::strcoll;
> using ::strncmp;
> using ::strxfrm;
> using ::strcspn;
> using ::strspn;
> using ::strtok;
> using ::memset;
> using ::strerror;
> using ::strlen;
>
> using ::memchr;
>
> inline void*
> memchr(void* __p, int __c, size_t __n)
> { return memchr(const_cast<const void*>(__p), __c, __n); }
>
> using ::strchr;
>
> inline char*
> strchr(char* __s1, int __n)
> { return __builtin_strchr(const_cast<const char*>(__s1), __n); }
>
> using ::strpbrk;
>
> inline char*
> strpbrk(char* __s1, const char* __s2)
> { return __builtin_strpbrk(const_cast<const char*>(__s1), __s2); }
>
> using ::strrchr;
>
> inline char*
> strrchr(char* __s1, int __n)
> { return __builtin_strrchr(const_cast<const char*>(__s1), __n); }
>
> using ::strstr;
>
> inline char*
> strstr(char* __s1, const char* __s2)
> { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
>}
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/clocale" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/clocale" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/clocale" 3
>
># 1 "/usr/include/locale.h" 1 3 4
># 29 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 27 "/usr/include/bits/locale.h" 3 4
>enum
>{
> __LC_CTYPE = 0,
> __LC_NUMERIC = 1,
> __LC_TIME = 2,
> __LC_COLLATE = 3,
> __LC_MONETARY = 4,
> __LC_MESSAGES = 5,
> __LC_ALL = 6,
> __LC_PAPER = 7,
> __LC_NAME = 8,
> __LC_ADDRESS = 9,
> __LC_TELEPHONE = 10,
> __LC_MEASUREMENT = 11,
> __LC_IDENTIFICATION = 12
>};
># 31 "/usr/include/locale.h" 2 3 4
>
>extern "C" {
># 52 "/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;
># 119 "/usr/include/locale.h" 3 4
>};
>
>
>
>
>
>extern char *setlocale (int __category, __const char *__locale) throw ();
>
>
>extern struct lconv *localeconv (void) throw ();
>
>
># 148 "/usr/include/locale.h" 3 4
>typedef __locale_t locale_t;
>
>
>
>
>
>extern __locale_t newlocale (int __category_mask, __const char *__locale,
> __locale_t __base) throw ();
># 189 "/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 ();
>
>
>
>
>
>
>
>}
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/clocale" 2 3
>
>
>
>
>
>namespace std
>{
> using ::lconv;
> using ::setlocale;
> using ::localeconv;
>}
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/include/langinfo.h" 1 3 4
># 24 "/usr/include/langinfo.h" 3 4
># 1 "/usr/include/nl_types.h" 1 3 4
># 31 "/usr/include/nl_types.h" 3 4
>extern "C" {
>
>
>typedef void *nl_catd;
>
>
>typedef int nl_item;
>
>
>
>
>
>extern nl_catd catopen (__const char *__cat_name, int __flag) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern char *catgets (nl_catd __catalog, int __set, int __number,
> __const char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int catclose (nl_catd __catalog) throw () __attribute__ ((__nonnull__ (1)));
>
>}
># 25 "/usr/include/langinfo.h" 2 3 4
>
># 1 "/usr/include/bits/locale.h" 1 3 4
># 27 "/usr/include/langinfo.h" 2 3 4
>
>
>extern "C" {
># 43 "/usr/include/langinfo.h" 3 4
>enum
>{
>
>
>
> ABDAY_1 = (((__LC_TIME) << 16) | (0)),
>
> ABDAY_2,
>
> ABDAY_3,
>
> ABDAY_4,
>
> ABDAY_5,
>
> ABDAY_6,
>
> ABDAY_7,
>
>
>
> DAY_1,
>
> DAY_2,
>
> DAY_3,
>
> DAY_4,
>
> DAY_5,
>
> DAY_6,
>
> DAY_7,
>
>
>
> ABMON_1,
>
> ABMON_2,
>
> ABMON_3,
>
> ABMON_4,
>
> ABMON_5,
>
> ABMON_6,
>
> ABMON_7,
>
> ABMON_8,
>
> ABMON_9,
>
> ABMON_10,
>
> ABMON_11,
>
> ABMON_12,
>
>
>
> MON_1,
>
> MON_2,
>
> MON_3,
>
> MON_4,
>
> MON_5,
>
> MON_6,
>
> MON_7,
>
> MON_8,
>
> MON_9,
>
> MON_10,
>
> MON_11,
>
> MON_12,
>
>
> AM_STR,
>
> PM_STR,
>
>
> D_T_FMT,
>
> D_FMT,
>
> T_FMT,
>
> T_FMT_AMPM,
>
>
> ERA,
>
> __ERA_YEAR,
>
>
>
> ERA_D_FMT,
>
> ALT_DIGITS,
>
> ERA_D_T_FMT,
>
> ERA_T_FMT,
>
>
> _NL_TIME_ERA_NUM_ENTRIES,
> _NL_TIME_ERA_ENTRIES,
>
> _NL_WABDAY_1,
> _NL_WABDAY_2,
> _NL_WABDAY_3,
> _NL_WABDAY_4,
> _NL_WABDAY_5,
> _NL_WABDAY_6,
> _NL_WABDAY_7,
>
>
> _NL_WDAY_1,
> _NL_WDAY_2,
> _NL_WDAY_3,
> _NL_WDAY_4,
> _NL_WDAY_5,
> _NL_WDAY_6,
> _NL_WDAY_7,
>
>
> _NL_WABMON_1,
> _NL_WABMON_2,
> _NL_WABMON_3,
> _NL_WABMON_4,
> _NL_WABMON_5,
> _NL_WABMON_6,
> _NL_WABMON_7,
> _NL_WABMON_8,
> _NL_WABMON_9,
> _NL_WABMON_10,
> _NL_WABMON_11,
> _NL_WABMON_12,
>
>
> _NL_WMON_1,
> _NL_WMON_2,
> _NL_WMON_3,
> _NL_WMON_4,
> _NL_WMON_5,
> _NL_WMON_6,
> _NL_WMON_7,
> _NL_WMON_8,
> _NL_WMON_9,
> _NL_WMON_10,
> _NL_WMON_11,
> _NL_WMON_12,
>
> _NL_WAM_STR,
> _NL_WPM_STR,
>
> _NL_WD_T_FMT,
> _NL_WD_FMT,
> _NL_WT_FMT,
> _NL_WT_FMT_AMPM,
>
> _NL_WERA_YEAR,
> _NL_WERA_D_FMT,
> _NL_WALT_DIGITS,
> _NL_WERA_D_T_FMT,
> _NL_WERA_T_FMT,
>
> _NL_TIME_WEEK_NDAYS,
> _NL_TIME_WEEK_1STDAY,
> _NL_TIME_WEEK_1STWEEK,
> _NL_TIME_FIRST_WEEKDAY,
> _NL_TIME_FIRST_WORKDAY,
> _NL_TIME_CAL_DIRECTION,
> _NL_TIME_TIMEZONE,
>
> _DATE_FMT,
>
> _NL_W_DATE_FMT,
>
> _NL_TIME_CODESET,
>
> _NL_NUM_LC_TIME,
>
>
>
>
> _NL_COLLATE_NRULES = (((__LC_COLLATE) << 16) | (0)),
> _NL_COLLATE_RULESETS,
> _NL_COLLATE_TABLEMB,
> _NL_COLLATE_WEIGHTMB,
> _NL_COLLATE_EXTRAMB,
> _NL_COLLATE_INDIRECTMB,
> _NL_COLLATE_GAP1,
> _NL_COLLATE_GAP2,
> _NL_COLLATE_GAP3,
> _NL_COLLATE_TABLEWC,
> _NL_COLLATE_WEIGHTWC,
> _NL_COLLATE_EXTRAWC,
> _NL_COLLATE_INDIRECTWC,
> _NL_COLLATE_SYMB_HASH_SIZEMB,
> _NL_COLLATE_SYMB_TABLEMB,
> _NL_COLLATE_SYMB_EXTRAMB,
> _NL_COLLATE_COLLSEQMB,
> _NL_COLLATE_COLLSEQWC,
> _NL_COLLATE_CODESET,
> _NL_NUM_LC_COLLATE,
>
>
>
>
> _NL_CTYPE_CLASS = (((__LC_CTYPE) << 16) | (0)),
> _NL_CTYPE_TOUPPER,
> _NL_CTYPE_GAP1,
> _NL_CTYPE_TOLOWER,
> _NL_CTYPE_GAP2,
> _NL_CTYPE_CLASS32,
> _NL_CTYPE_GAP3,
> _NL_CTYPE_GAP4,
> _NL_CTYPE_GAP5,
> _NL_CTYPE_GAP6,
> _NL_CTYPE_CLASS_NAMES,
> _NL_CTYPE_MAP_NAMES,
> _NL_CTYPE_WIDTH,
> _NL_CTYPE_MB_CUR_MAX,
> _NL_CTYPE_CODESET_NAME,
> CODESET = _NL_CTYPE_CODESET_NAME,
>
> _NL_CTYPE_TOUPPER32,
> _NL_CTYPE_TOLOWER32,
> _NL_CTYPE_CLASS_OFFSET,
> _NL_CTYPE_MAP_OFFSET,
> _NL_CTYPE_INDIGITS_MB_LEN,
> _NL_CTYPE_INDIGITS0_MB,
> _NL_CTYPE_INDIGITS1_MB,
> _NL_CTYPE_INDIGITS2_MB,
> _NL_CTYPE_INDIGITS3_MB,
> _NL_CTYPE_INDIGITS4_MB,
> _NL_CTYPE_INDIGITS5_MB,
> _NL_CTYPE_INDIGITS6_MB,
> _NL_CTYPE_INDIGITS7_MB,
> _NL_CTYPE_INDIGITS8_MB,
> _NL_CTYPE_INDIGITS9_MB,
> _NL_CTYPE_INDIGITS_WC_LEN,
> _NL_CTYPE_INDIGITS0_WC,
> _NL_CTYPE_INDIGITS1_WC,
> _NL_CTYPE_INDIGITS2_WC,
> _NL_CTYPE_INDIGITS3_WC,
> _NL_CTYPE_INDIGITS4_WC,
> _NL_CTYPE_INDIGITS5_WC,
> _NL_CTYPE_INDIGITS6_WC,
> _NL_CTYPE_INDIGITS7_WC,
> _NL_CTYPE_INDIGITS8_WC,
> _NL_CTYPE_INDIGITS9_WC,
> _NL_CTYPE_OUTDIGIT0_MB,
> _NL_CTYPE_OUTDIGIT1_MB,
> _NL_CTYPE_OUTDIGIT2_MB,
> _NL_CTYPE_OUTDIGIT3_MB,
> _NL_CTYPE_OUTDIGIT4_MB,
> _NL_CTYPE_OUTDIGIT5_MB,
> _NL_CTYPE_OUTDIGIT6_MB,
> _NL_CTYPE_OUTDIGIT7_MB,
> _NL_CTYPE_OUTDIGIT8_MB,
> _NL_CTYPE_OUTDIGIT9_MB,
> _NL_CTYPE_OUTDIGIT0_WC,
> _NL_CTYPE_OUTDIGIT1_WC,
> _NL_CTYPE_OUTDIGIT2_WC,
> _NL_CTYPE_OUTDIGIT3_WC,
> _NL_CTYPE_OUTDIGIT4_WC,
> _NL_CTYPE_OUTDIGIT5_WC,
> _NL_CTYPE_OUTDIGIT6_WC,
> _NL_CTYPE_OUTDIGIT7_WC,
> _NL_CTYPE_OUTDIGIT8_WC,
> _NL_CTYPE_OUTDIGIT9_WC,
> _NL_CTYPE_TRANSLIT_TAB_SIZE,
> _NL_CTYPE_TRANSLIT_FROM_IDX,
> _NL_CTYPE_TRANSLIT_FROM_TBL,
> _NL_CTYPE_TRANSLIT_TO_IDX,
> _NL_CTYPE_TRANSLIT_TO_TBL,
> _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN,
> _NL_CTYPE_TRANSLIT_DEFAULT_MISSING,
> _NL_CTYPE_TRANSLIT_IGNORE_LEN,
> _NL_CTYPE_TRANSLIT_IGNORE,
> _NL_CTYPE_MAP_TO_NONASCII,
> _NL_CTYPE_EXTRA_MAP_1,
> _NL_CTYPE_EXTRA_MAP_2,
> _NL_CTYPE_EXTRA_MAP_3,
> _NL_CTYPE_EXTRA_MAP_4,
> _NL_CTYPE_EXTRA_MAP_5,
> _NL_CTYPE_EXTRA_MAP_6,
> _NL_CTYPE_EXTRA_MAP_7,
> _NL_CTYPE_EXTRA_MAP_8,
> _NL_CTYPE_EXTRA_MAP_9,
> _NL_CTYPE_EXTRA_MAP_10,
> _NL_CTYPE_EXTRA_MAP_11,
> _NL_CTYPE_EXTRA_MAP_12,
> _NL_CTYPE_EXTRA_MAP_13,
> _NL_CTYPE_EXTRA_MAP_14,
> _NL_NUM_LC_CTYPE,
>
>
>
>
> __INT_CURR_SYMBOL = (((__LC_MONETARY) << 16) | (0)),
>
>
>
> __CURRENCY_SYMBOL,
>
>
>
> __MON_DECIMAL_POINT,
>
>
>
> __MON_THOUSANDS_SEP,
>
>
>
> __MON_GROUPING,
>
>
>
> __POSITIVE_SIGN,
>
>
>
> __NEGATIVE_SIGN,
>
>
>
> __INT_FRAC_DIGITS,
>
>
>
> __FRAC_DIGITS,
>
>
>
> __P_CS_PRECEDES,
>
>
>
> __P_SEP_BY_SPACE,
>
>
>
> __N_CS_PRECEDES,
>
>
>
> __N_SEP_BY_SPACE,
>
>
>
> __P_SIGN_POSN,
>
>
>
> __N_SIGN_POSN,
>
>
>
> _NL_MONETARY_CRNCYSTR,
>
> __INT_P_CS_PRECEDES,
>
>
>
> __INT_P_SEP_BY_SPACE,
>
>
>
> __INT_N_CS_PRECEDES,
>
>
>
> __INT_N_SEP_BY_SPACE,
>
>
>
> __INT_P_SIGN_POSN,
>
>
>
> __INT_N_SIGN_POSN,
>
>
>
> _NL_MONETARY_DUO_INT_CURR_SYMBOL,
> _NL_MONETARY_DUO_CURRENCY_SYMBOL,
> _NL_MONETARY_DUO_INT_FRAC_DIGITS,
> _NL_MONETARY_DUO_FRAC_DIGITS,
> _NL_MONETARY_DUO_P_CS_PRECEDES,
> _NL_MONETARY_DUO_P_SEP_BY_SPACE,
> _NL_MONETARY_DUO_N_CS_PRECEDES,
> _NL_MONETARY_DUO_N_SEP_BY_SPACE,
> _NL_MONETARY_DUO_INT_P_CS_PRECEDES,
> _NL_MONETARY_DUO_INT_P_SEP_BY_SPACE,
> _NL_MONETARY_DUO_INT_N_CS_PRECEDES,
> _NL_MONETARY_DUO_INT_N_SEP_BY_SPACE,
> _NL_MONETARY_DUO_P_SIGN_POSN,
> _NL_MONETARY_DUO_N_SIGN_POSN,
> _NL_MONETARY_DUO_INT_P_SIGN_POSN,
> _NL_MONETARY_DUO_INT_N_SIGN_POSN,
> _NL_MONETARY_UNO_VALID_FROM,
> _NL_MONETARY_UNO_VALID_TO,
> _NL_MONETARY_DUO_VALID_FROM,
> _NL_MONETARY_DUO_VALID_TO,
> _NL_MONETARY_CONVERSION_RATE,
> _NL_MONETARY_DECIMAL_POINT_WC,
> _NL_MONETARY_THOUSANDS_SEP_WC,
> _NL_MONETARY_CODESET,
> _NL_NUM_LC_MONETARY,
>
>
>
> __DECIMAL_POINT = (((__LC_NUMERIC) << 16) | (0)),
>
>
>
> RADIXCHAR = __DECIMAL_POINT,
>
> __THOUSANDS_SEP,
>
>
>
> THOUSEP = __THOUSANDS_SEP,
>
> __GROUPING,
>
>
>
> _NL_NUMERIC_DECIMAL_POINT_WC,
> _NL_NUMERIC_THOUSANDS_SEP_WC,
> _NL_NUMERIC_CODESET,
> _NL_NUM_LC_NUMERIC,
>
> __YESEXPR = (((__LC_MESSAGES) << 16) | (0)),
>
> __NOEXPR,
>
> __YESSTR,
>
>
>
> __NOSTR,
>
>
>
> _NL_MESSAGES_CODESET,
> _NL_NUM_LC_MESSAGES,
>
> _NL_PAPER_HEIGHT = (((__LC_PAPER) << 16) | (0)),
> _NL_PAPER_WIDTH,
> _NL_PAPER_CODESET,
> _NL_NUM_LC_PAPER,
>
> _NL_NAME_NAME_FMT = (((__LC_NAME) << 16) | (0)),
> _NL_NAME_NAME_GEN,
> _NL_NAME_NAME_MR,
> _NL_NAME_NAME_MRS,
> _NL_NAME_NAME_MISS,
> _NL_NAME_NAME_MS,
> _NL_NAME_CODESET,
> _NL_NUM_LC_NAME,
>
> _NL_ADDRESS_POSTAL_FMT = (((__LC_ADDRESS) << 16) | (0)),
> _NL_ADDRESS_COUNTRY_NAME,
> _NL_ADDRESS_COUNTRY_POST,
> _NL_ADDRESS_COUNTRY_AB2,
> _NL_ADDRESS_COUNTRY_AB3,
> _NL_ADDRESS_COUNTRY_CAR,
> _NL_ADDRESS_COUNTRY_NUM,
> _NL_ADDRESS_COUNTRY_ISBN,
> _NL_ADDRESS_LANG_NAME,
> _NL_ADDRESS_LANG_AB,
> _NL_ADDRESS_LANG_TERM,
> _NL_ADDRESS_LANG_LIB,
> _NL_ADDRESS_CODESET,
> _NL_NUM_LC_ADDRESS,
>
> _NL_TELEPHONE_TEL_INT_FMT = (((__LC_TELEPHONE) << 16) | (0)),
> _NL_TELEPHONE_TEL_DOM_FMT,
> _NL_TELEPHONE_INT_SELECT,
> _NL_TELEPHONE_INT_PREFIX,
> _NL_TELEPHONE_CODESET,
> _NL_NUM_LC_TELEPHONE,
>
> _NL_MEASUREMENT_MEASUREMENT = (((__LC_MEASUREMENT) << 16) | (0)),
> _NL_MEASUREMENT_CODESET,
> _NL_NUM_LC_MEASUREMENT,
>
> _NL_IDENTIFICATION_TITLE = (((__LC_IDENTIFICATION) << 16) | (0)),
> _NL_IDENTIFICATION_SOURCE,
> _NL_IDENTIFICATION_ADDRESS,
> _NL_IDENTIFICATION_CONTACT,
> _NL_IDENTIFICATION_EMAIL,
> _NL_IDENTIFICATION_TEL,
> _NL_IDENTIFICATION_FAX,
> _NL_IDENTIFICATION_LANGUAGE,
> _NL_IDENTIFICATION_TERRITORY,
> _NL_IDENTIFICATION_AUDIENCE,
> _NL_IDENTIFICATION_APPLICATION,
> _NL_IDENTIFICATION_ABBREVIATION,
> _NL_IDENTIFICATION_REVISION,
> _NL_IDENTIFICATION_DATE,
> _NL_IDENTIFICATION_CATEGORY,
> _NL_IDENTIFICATION_CODESET,
> _NL_NUM_LC_IDENTIFICATION,
>
>
> _NL_NUM
>};
># 576 "/usr/include/langinfo.h" 3 4
>extern char *nl_langinfo (nl_item __item) throw ();
># 587 "/usr/include/langinfo.h" 3 4
>extern char *nl_langinfo_l (nl_item __item, __locale_t l);
>
>
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/include/iconv.h" 1 3 4
># 24 "/usr/include/iconv.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 25 "/usr/include/iconv.h" 2 3 4
>
>
>extern "C" {
>
>
>typedef void *iconv_t;
>
>
>
>
>
>
>
>extern iconv_t iconv_open (__const char *__tocode, __const char *__fromcode);
>
>
>
>
>extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
> size_t *__restrict __inbytesleft,
> char **__restrict __outbuf,
> size_t *__restrict __outbytesleft);
>
>
>
>
>
>extern int iconv_close (iconv_t __cd);
>
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 2 3
># 1 "/usr/include/libintl.h" 1 3 4
># 35 "/usr/include/libintl.h" 3 4
>extern "C" {
>
>
>
>
>extern char *gettext (__const char *__msgid) throw ();
>
>
>
>extern char *dgettext (__const char *__domainname, __const char *__msgid)
> throw ();
>extern char *__dgettext (__const char *__domainname, __const char *__msgid)
> throw () __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dcgettext (__const char *__domainname,
> __const char *__msgid, int __category) throw ();
>extern char *__dcgettext (__const char *__domainname,
> __const char *__msgid, int __category)
> throw () __attribute__ ((__format_arg__ (2)));
>
>
>
>
>extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
> unsigned long int __n)
> throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
>
>
>
>extern char *dngettext (__const char *__domainname, __const char *__msgid1,
> __const char *__msgid2, unsigned long int __n)
> throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
> __const char *__msgid2, unsigned long int __n,
> int __category)
> throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
>
>
>
>
>
>extern char *textdomain (__const char *__domainname) throw ();
>
>
>
>extern char *bindtextdomain (__const char *__domainname,
> __const char *__dirname) throw ();
>
>
>
>extern char *bind_textdomain_codeset (__const char *__domainname,
> __const char *__codeset) throw ();
># 120 "/usr/include/libintl.h" 3 4
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 2 3
>
>
>
>
>
>
>namespace __gnu_cxx
>{
> extern "C" __typeof(uselocale) __uselocale;
>}
>
>
>namespace std
>{
> typedef __locale_t __c_locale;
>
>
>
>
>
> template<typename _Tv>
> int
> __convert_from_v(char* __out, const int __size, const char* __fmt,
>
> _Tv __v, const __c_locale& __cloc, int __prec)
> {
> __c_locale __old = __gnu_cxx::__uselocale(__cloc);
># 84 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++locale.h" 3
> const int __ret = std::snprintf(__out, __size, __fmt, __prec, __v);
>
>
>
>
>
> __gnu_cxx::__uselocale(__old);
>
>
>
>
> return __ret;
> }
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++io.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++io.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr.h" 1 3
># 104 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr-default.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr-default.h" 3
># 1 "/usr/include/pthread.h" 1 3 4
># 20 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 29 "/usr/include/sched.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 30 "/usr/include/sched.h" 2 3 4
>
>
># 1 "/usr/include/bits/sched.h" 1 3 4
># 62 "/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 ();
>
>
>}
>
>
>
>
>
>
>
>struct __sched_param
> {
> int __sched_priority;
> };
># 98 "/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;
># 33 "/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 ();
># 76 "/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 ();
>
>
>}
># 21 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 30 "/usr/include/time.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 39 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 43 "/usr/include/time.h" 2 3 4
># 58 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 92 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 104 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 129 "/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;
># 178 "/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 ();
># 309 "/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__));
># 324 "/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 ();
># 386 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 395 "/usr/include/time.h" 3 4
>extern struct tm *getdate (__const char *__string);
># 409 "/usr/include/time.h" 3 4
>extern int getdate_r (__const char *__restrict __string,
> struct tm *__restrict __resbufp);
>
>
>}
># 22 "/usr/include/pthread.h" 2 3 4
>
>
># 1 "/usr/include/signal.h" 1 3 4
># 31 "/usr/include/signal.h" 3 4
>extern "C" {
>
># 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/signal.h" 2 3 4
># 50 "/usr/include/signal.h" 3 4
>typedef __sigset_t sigset_t;
># 400 "/usr/include/signal.h" 3 4
>}
># 25 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 23 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/sched.h" 1 3 4
># 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
>
>
>struct _pthread_fastlock
>{
> long int __status;
> int __spinlock;
>
>};
>
>
>
>typedef struct _pthread_descr_struct *_pthread_descr;
>
>
>
>
>
>typedef struct __pthread_attr_s
>{
> int __detachstate;
> int __schedpolicy;
> struct __sched_param __schedparam;
> int __inheritsched;
> int __scope;
> size_t __guardsize;
> int __stackaddr_set;
> void *__stackaddr;
> size_t __stacksize;
>} pthread_attr_t;
>
>
>
>
>
>__extension__ typedef long long __pthread_cond_align_t;
>
>
>
>
>typedef struct
>{
> struct _pthread_fastlock __c_lock;
> _pthread_descr __c_waiting;
> char __padding[48 - sizeof (struct _pthread_fastlock)
> - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
> __pthread_cond_align_t __align;
>} pthread_cond_t;
>
>
>
>typedef struct
>{
> int __dummy;
>} pthread_condattr_t;
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>
>
>typedef struct
>{
> int __m_reserved;
> int __m_count;
> _pthread_descr __m_owner;
> int __m_kind;
> struct _pthread_fastlock __m_lock;
>} pthread_mutex_t;
>
>
>
>typedef struct
>{
> int __mutexkind;
>} pthread_mutexattr_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>typedef struct _pthread_rwlock_t
>{
> struct _pthread_fastlock __rw_lock;
> int __rw_readers;
> _pthread_descr __rw_writer;
> _pthread_descr __rw_read_waiting;
> _pthread_descr __rw_write_waiting;
> int __rw_kind;
> int __rw_pshared;
>} pthread_rwlock_t;
>
>
>
>typedef struct
>{
> int __lockkind;
> int __pshared;
>} pthread_rwlockattr_t;
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>typedef struct {
> struct _pthread_fastlock __ba_lock;
> int __ba_required;
> int __ba_present;
> _pthread_descr __ba_waiting;
>} pthread_barrier_t;
>
>
>typedef struct {
> int __pshared;
>} pthread_barrierattr_t;
>
>
>
>
>
>typedef unsigned long int pthread_t;
># 26 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/initspin.h" 1 3 4
># 27 "/usr/include/pthread.h" 2 3 4
>
>
>extern "C" {
># 59 "/usr/include/pthread.h" 3 4
>enum
>{
> PTHREAD_CREATE_JOINABLE,
>
> PTHREAD_CREATE_DETACHED
>
>};
>
>enum
>{
> PTHREAD_INHERIT_SCHED,
>
> PTHREAD_EXPLICIT_SCHED
>
>};
>
>enum
>{
> PTHREAD_SCOPE_SYSTEM,
>
> PTHREAD_SCOPE_PROCESS
>
>};
>
>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_ADAPTIVE_NP
>
>};
>
>enum
>{
> PTHREAD_PROCESS_PRIVATE,
>
> PTHREAD_PROCESS_SHARED
>
>};
>
>
>enum
>{
> PTHREAD_RWLOCK_PREFER_READER_NP,
> PTHREAD_RWLOCK_PREFER_WRITER_NP,
> PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
> PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
>};
># 131 "/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
>
>};
># 163 "/usr/include/pthread.h" 3 4
>extern int pthread_create (pthread_t *__restrict __threadp,
> __const pthread_attr_t *__restrict __attr,
> void *(*__start_routine) (void *),
> void *__restrict __arg) throw ();
>
>
>extern pthread_t pthread_self (void) throw ();
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();
>
>
>extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
>
>
>
>
>extern int pthread_join (pthread_t __th, void **__thread_return);
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) throw ();
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) throw ();
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr) throw ();
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
> int __detachstate) throw ();
>
>
>extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
> int *__detachstate) throw ();
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
> __const struct sched_param *__restrict
> __param) throw ();
>
>
>extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
> __attr,
> struct sched_param *__restrict __param)
> throw ();
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
> throw ();
>
>
>extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
> __attr, int *__restrict __policy)
> throw ();
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
> int __inherit) throw ();
>
>
>extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
> __attr, int *__restrict __inherit)
> throw ();
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
> throw ();
>
>
>extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
> int *__restrict __scope) throw ();
>
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
> size_t __guardsize) throw ();
>
>
>extern int pthread_attr_getguardsize (__const pthread_attr_t *__restrict
> __attr, size_t *__restrict __guardsize)
> throw ();
>
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
> void *__stackaddr) throw ();
>
>
>extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
> __attr, void **__restrict __stackaddr)
> throw ();
>
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
> size_t __stacksize) throw ();
>
>
>extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
> void **__restrict __stackaddr,
> size_t *__restrict __stacksize) throw ();
>
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
> size_t __stacksize) throw ();
>
>
>extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
> __attr, size_t *__restrict __stacksize)
> throw ();
>
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) throw ();
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
> __const struct sched_param *__param)
> throw ();
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
> int *__restrict __policy,
> struct sched_param *__restrict __param)
> throw ();
>
>
>
>extern int pthread_getconcurrency (void) throw ();
>
>
>extern int pthread_setconcurrency (int __level) throw ();
>
>
>
>
>
>
>
>extern int pthread_yield (void) throw ();
>
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__restrict __mutex,
> __const pthread_mutexattr_t *__restrict
> __mutex_attr) throw ();
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) throw ();
>
>
>extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) throw ();
>
>
>extern int pthread_mutex_lock (pthread_mutex_t *__mutex) throw ();
>
>
>
>extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
> __const struct timespec *__restrict
> __abstime) throw ();
>
>
>
>extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) throw ();
>
>
>
>
>
>
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw ();
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw ();
>
>
>extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __pshared) throw ();
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
> int __pshared) throw ();
>
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
> throw ();
>
>
>extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
> __attr, int *__restrict __kind) throw ();
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
> __const pthread_condattr_t *__restrict
> __cond_attr) throw ();
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond) throw ();
>
>
>extern int pthread_cond_signal (pthread_cond_t *__cond) throw ();
>
>
>extern int pthread_cond_broadcast (pthread_cond_t *__cond) throw ();
>
>
>
>extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex);
>
>
>
>
>
>extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex,
> __const struct timespec *__restrict
> __abstime);
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr) throw ();
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr) throw ();
>
>
>extern int pthread_condattr_getpshared (__const pthread_condattr_t *
> __restrict __attr,
> int *__restrict __pshared) throw ();
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
> int __pshared) throw ();
>
>
>
>
>
>
>
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
> __const pthread_rwlockattr_t *__restrict
> __attr) throw ();
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) throw ();
>
>
>extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) throw ();
>
>
>extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) throw ();
>
>
>
>extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
> __const struct timespec *__restrict
> __abstime) throw ();
>
>
>
>extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) throw ();
>
>
>extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) throw ();
>
>
>
>extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
> __const struct timespec *__restrict
> __abstime) throw ();
>
>
>
>extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) throw ();
>
>
>
>
>
>extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) throw ();
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) throw ();
>
>
>extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pshared) throw ();
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
> int __pshared) throw ();
>
>
>extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *__attr,
> int *__pref) throw ();
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
> int __pref) throw ();
># 510 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
> throw ();
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock) throw ();
>
>
>extern int pthread_spin_lock (pthread_spinlock_t *__lock) throw ();
>
>
>extern int pthread_spin_trylock (pthread_spinlock_t *__lock) throw ();
>
>
>extern int pthread_spin_unlock (pthread_spinlock_t *__lock) throw ();
>
>
>
>
>extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
> __const pthread_barrierattr_t *__restrict
> __attr, unsigned int __count) throw ();
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) throw ();
>
>extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) throw ();
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) throw ();
>
>extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
> __restrict __attr,
> int *__restrict __pshared) throw ();
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
> int __pshared) throw ();
>
>extern int pthread_barrier_wait (pthread_barrier_t *__barrier) throw ();
># 557 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
> void (*__destr_function) (void *)) throw ();
>
>
>extern int pthread_key_delete (pthread_key_t __key) throw ();
>
>
>extern int pthread_setspecific (pthread_key_t __key,
> __const void *__pointer) throw ();
>
>
>extern void *pthread_getspecific (pthread_key_t __key) throw ();
># 580 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
> void (*__init_routine) (void));
>
>
>
>
>
>
>extern int pthread_setcancelstate (int __state, int *__oldstate);
>
>
>
>extern int pthread_setcanceltype (int __type, int *__oldtype);
>
>
>extern int pthread_cancel (pthread_t __cancelthread);
>
>
>
>
>extern void pthread_testcancel (void);
># 614 "/usr/include/pthread.h" 3 4
>extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,
> void (*__routine) (void *),
> void *__arg) throw ();
>
>
>
>
>
>
>
>extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,
> int __execute) throw ();
># 635 "/usr/include/pthread.h" 3 4
>extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
> void (*__routine) (void *),
> void *__arg) throw ();
># 646 "/usr/include/pthread.h" 3 4
>extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
> int __execute) throw ();
>
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
> __clockid_t *__clock_id) throw ();
>
>
>
>
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 31 "/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 ();
># 660 "/usr/include/pthread.h" 2 3 4
># 675 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
> void (*__parent) (void),
> void (*__child) (void)) throw ();
>
>
>
>
>extern void pthread_kill_other_threads_np (void) throw ();
>
>}
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr-default.h" 2 3
>
>
>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;
># 63 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr-default.h" 3
>#pragma weak pthread_once
>#pragma weak pthread_key_create
>#pragma weak pthread_key_delete
>#pragma weak pthread_getspecific
>#pragma weak pthread_setspecific
>#pragma weak pthread_create
>
>#pragma weak pthread_mutex_lock
>#pragma weak pthread_mutex_trylock
>#pragma weak pthread_mutex_unlock
>#pragma weak pthread_mutexattr_init
>#pragma weak pthread_mutexattr_settype
>#pragma weak pthread_mutexattr_destroy
>
>#pragma weak pthread_mutex_init
># 105 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_active_p (void)
>{
> static void *const __gthread_active_ptr = (void *) &pthread_create;
> return __gthread_active_ptr != 0;
>}
># 467 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_once (__gthread_once_t *once, void (*func) (void))
>{
> if (__gthread_active_p ())
> return pthread_once (once, func);
> else
> return -1;
>}
>
>static inline int
>__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
>{
> return pthread_key_create (key, dtor);
>}
>
>static inline int
>__gthread_key_delete (__gthread_key_t key)
>{
> return pthread_key_delete (key);
>}
>
>static inline void *
>__gthread_getspecific (__gthread_key_t key)
>{
> return pthread_getspecific (key);
>}
>
>static inline int
>__gthread_setspecific (__gthread_key_t key, const void *ptr)
>{
> return pthread_setspecific (key, ptr);
>}
>
>static inline int
>__gthread_mutex_lock (__gthread_mutex_t *mutex)
>{
> if (__gthread_active_p ())
> return pthread_mutex_lock (mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_trylock (__gthread_mutex_t *mutex)
>{
> if (__gthread_active_p ())
> return pthread_mutex_trylock (mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_unlock (__gthread_mutex_t *mutex)
>{
> if (__gthread_active_p ())
> return pthread_mutex_unlock (mutex);
> else
> return 0;
>}
># 548 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-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_unlock (__gthread_recursive_mutex_t *mutex)
>{
> return __gthread_mutex_unlock (mutex);
>}
># 105 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/gthr.h" 2 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++io.h" 2 3
>
>namespace std
>{
> typedef __gthread_mutex_t __c_lock;
>
>
> typedef FILE __c_file;
>
>
>
> struct __ios_flags
> {
> typedef short __int_type;
>
> static const __int_type _S_boolalpha = 0x0001;
> static const __int_type _S_dec = 0x0002;
> static const __int_type _S_fixed = 0x0004;
> static const __int_type _S_hex = 0x0008;
> static const __int_type _S_internal = 0x0010;
> static const __int_type _S_left = 0x0020;
> static const __int_type _S_oct = 0x0040;
> static const __int_type _S_right = 0x0080;
> static const __int_type _S_scientific = 0x0100;
> static const __int_type _S_showbase = 0x0200;
> static const __int_type _S_showpoint = 0x0400;
> static const __int_type _S_showpos = 0x0800;
> static const __int_type _S_skipws = 0x1000;
> static const __int_type _S_unitbuf = 0x2000;
> static const __int_type _S_uppercase = 0x4000;
> static const __int_type _S_adjustfield = 0x0020 | 0x0080 | 0x0010;
> static const __int_type _S_basefield = 0x0002 | 0x0040 | 0x0008;
> static const __int_type _S_floatfield = 0x0100 | 0x0004;
>
>
> static const __int_type _S_badbit = 0x01;
> static const __int_type _S_eofbit = 0x02;
> static const __int_type _S_failbit = 0x04;
>
>
> static const __int_type _S_app = 0x01;
> static const __int_type _S_ate = 0x02;
> static const __int_type _S_bin = 0x04;
> static const __int_type _S_in = 0x08;
> static const __int_type _S_out = 0x10;
> static const __int_type _S_trunc = 0x20;
> };
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cctype" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cctype" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cctype" 3
>
>
># 1 "/usr/include/ctype.h" 1 3 4
># 30 "/usr/include/ctype.h" 3 4
>extern "C" {
># 41 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 38 "/usr/include/endian.h" 2 3 4
># 42 "/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))
>};
># 81 "/usr/include/ctype.h" 3 4
>extern __const unsigned short int **__ctype_b_loc (void)
> __attribute__ ((__const));
>extern __const __int32_t **__ctype_tolower_loc (void)
> __attribute__ ((__const));
>extern __const __int32_t **__ctype_toupper_loc (void)
> __attribute__ ((__const));
># 96 "/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 ();
># 247 "/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 ();
># 323 "/usr/include/ctype.h" 3 4
>}
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cctype" 2 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stringfwd.h" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stringfwd.h" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stringfwd.h" 3
>
>
>
>namespace std
>{
> template<typename _Alloc>
> class allocator;
>
> 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;
>
>}
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 1 3
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 3
> 
># 45 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ctime" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ctime" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ctime" 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ctime" 3
>namespace std
>{
> using ::clock_t;
> using ::time_t;
> using ::tm;
>
> using ::clock;
> using ::difftime;
> using ::mktime;
> using ::time;
> using ::asctime;
> using ::ctime;
> using ::gmtime;
> using ::localtime;
> using ::strftime;
>}
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 2 3
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 40 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stdarg.h" 1 3 4
># 41 "/usr/include/wchar.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 49 "/usr/include/wchar.h" 2 3 4
># 93 "/usr/include/wchar.h" 3 4
>
>
>typedef __mbstate_t mbstate_t;
>
>
>
># 118 "/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 ();
>
>
>
>
>
>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 wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
> throw () __attribute__ ((__pure__));
>
>extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
> throw () __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 wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept)
> throw () __attribute__ ((__pure__));
>
>extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
> throw () __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 wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
> throw () __attribute__ ((__pure__));
>
>
>
>
>extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>extern int wmemcmp (__const wchar_t *__restrict __s1,
> __const wchar_t *__restrict __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 *__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 ();
>
># 330 "/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 ();
># 449 "/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 double __wcstod_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __group)
> throw ();
>extern float __wcstof_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __group)
> throw ();
>extern long double __wcstold_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __group) throw ();
>
>
>extern long int __wcstol_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, int __group) throw ();
>
>
>
>extern unsigned long int __wcstoul_internal (__const wchar_t *__restrict __npt,
> wchar_t **__restrict __endptr,
> int __base, int __group) throw ();
>
>
>
>__extension__
>extern long long int __wcstoll_internal (__const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, int __group) throw ();
>
>
>
>__extension__
>extern unsigned long long int __wcstoull_internal (__const wchar_t *
> __restrict __nptr,
> wchar_t **
> __restrict __endptr,
> int __base,
> int __group) throw ();
># 571 "/usr/include/wchar.h" 3 4
>extern wchar_t *wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ();
>
>
>
>extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
> 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 () ;
>
>
>
>
>
>
>
>
>
>
>
>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 () ;
>
>
>
>
>
>
>
>
>
>
>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);
>
># 739 "/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);
># 765 "/usr/include/wchar.h" 3 4
>extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
>extern wint_t putwchar_unlocked (wchar_t __wc);
># 775 "/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 ();
># 820 "/usr/include/wchar.h" 3 4
>}
># 55 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 2 3
># 69 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 3
>namespace std
>{
> using ::mbstate_t;
>}
># 141 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 3
>namespace std
>{
> 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;
>
> inline wchar_t*
> wcschr(wchar_t* __p, wchar_t __c)
> { return wcschr(const_cast<const wchar_t*>(__p), __c); }
>
> using ::wcspbrk;
>
> inline wchar_t*
> wcspbrk(wchar_t* __s1, wchar_t* __s2)
> { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
>
> using ::wcsrchr;
>
> inline wchar_t*
> wcsrchr(wchar_t* __p, wchar_t __c)
> { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
>
> using ::wcsstr;
>
> inline wchar_t*
> wcsstr(wchar_t* __s1, const wchar_t* __s2)
> { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
>
> using ::wmemchr;
>
> inline wchar_t*
> wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
> { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
>}
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
> using ::wcstold;
># 258 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwchar" 3
> using ::wcstoll;
> using ::wcstoull;
>
>}
>
>namespace std
>{
> using __gnu_cxx::wcstold;
> using __gnu_cxx::wcstoll;
> using __gnu_cxx::wcstoull;
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 2 3
>
>
># 1 "/usr/include/stdint.h" 1 3 4
># 28 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/stdint.h" 2 3 4
># 37 "/usr/include/stdint.h" 3 4
>typedef signed char int8_t;
>typedef short int int16_t;
>typedef int int32_t;
>
>
>
>__extension__
>typedef long long int int64_t;
>
>
>
>
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>
>
>__extension__
>typedef unsigned long long int uint64_t;
>
>
>
>
>
>
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>
>
>__extension__
>typedef long long int int_least64_t;
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>
>
>__extension__
>typedef unsigned long long int uint_least64_t;
>
>
>
>
>
>
>typedef signed char int_fast8_t;
>
>
>
>
>
>typedef int int_fast16_t;
>typedef int int_fast32_t;
>__extension__
>typedef long long int int_fast64_t;
>
>
>
>typedef unsigned char uint_fast8_t;
>
>
>
>
>
>typedef unsigned int uint_fast16_t;
>typedef unsigned int uint_fast32_t;
>__extension__
>typedef unsigned long long int uint_fast64_t;
># 129 "/usr/include/stdint.h" 3 4
>typedef unsigned int uintptr_t;
># 138 "/usr/include/stdint.h" 3 4
>__extension__
>typedef long long int intmax_t;
>__extension__
>typedef unsigned long long int uintmax_t;
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 2 3
>
>
>namespace std
>{
># 72 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 3
> typedef int64_t streamoff;
>
>
>
>
>
> typedef ptrdiff_t streamsize;
>
> template<typename _StateT>
> class fpos;
># 94 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/postypes.h" 3
> template<typename _StateT>
> class fpos
> {
> private:
> streamoff _M_off;
> _StateT _M_state;
>
> public:
>
>
>
>
> fpos()
> : _M_off(0), _M_state() { }
># 116 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
>
>
>
>
>
>
> bool
> operator==(const fpos& __other) const
> { return _M_off == __other._M_off; }
>
>
> bool
> operator!=(const fpos& __other) const
> { return _M_off != __other._M_off; }
>
>
>
>
>
> 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; }
> };
>
>
>
>
>
> typedef fpos<mbstate_t> streampos;
>
> typedef fpos<mbstate_t> wstreampos;
>}
># 51 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 1 3
># 34 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/exception_defines.h" 1 3
># 35 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 2 3
>
>namespace std
>{
>
> void
> __throw_bad_exception(void);
>
>
> void
> __throw_bad_alloc(void);
>
>
> void
> __throw_bad_cast(void);
>
> void
> __throw_bad_typeid(void);
>
>
> void
> __throw_logic_error(const char* __s);
>
> void
> __throw_domain_error(const char* __s);
>
> void
> __throw_invalid_argument(const char* __s);
>
> void
> __throw_length_error(const char* __s);
>
> void
> __throw_out_of_range(const char* __s);
>
> void
> __throw_runtime_error(const char* __s);
>
> void
> __throw_range_error(const char* __s);
>
> void
> __throw_overflow_error(const char* __s);
>
> void
> __throw_underflow_error(const char* __s);
>
>
> void
> __throw_ios_failure(const char* __s);
>}
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 2 3
>
>namespace std
>{
> 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;
>
>
>
> class ios_base;
># 136 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iosfwd" 3
> 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;
>
>
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/exception" 1 3
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/exception" 3
>extern "C++" {
>
>namespace std
>{
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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();
> };
>
>
> typedef void (*terminate_handler) ();
>
> typedef void (*unexpected_handler) ();
>
>
> terminate_handler set_terminate(terminate_handler) throw();
>
>
> void terminate() __attribute__ ((__noreturn__));
>
>
> unexpected_handler set_unexpected(unexpected_handler) throw();
>
>
> void unexpected() __attribute__ ((__noreturn__));
># 100 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/exception" 3
> bool uncaught_exception() throw();
>}
>
>namespace __gnu_cxx
>{
># 115 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/exception" 3
> void __verbose_terminate_handler ();
>}
>
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/char_traits.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/char_traits.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/char_traits.h" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/climits" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/climits" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/climits" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 1 3 4
># 11 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 1 3 4
># 122 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 144 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 153 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 36 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 37 "/usr/include/bits/local_lim.h" 2 3 4
># 154 "/usr/include/bits/posix1_lim.h" 2 3 4
># 145 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 149 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 35 "/usr/include/bits/xopen_lim.h" 2 3 4
># 153 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/syslimits.h" 2 3 4
># 12 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 2 3 4
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/climits" 2 3
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 3
>
>
>
>
># 1 "/usr/include/stdlib.h" 1 3 4
># 33 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 34 "/usr/include/stdlib.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 43 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 67 "/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;
> };
># 44 "/usr/include/stdlib.h" 2 3 4
># 96 "/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;
>
>
># 140 "/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)));
>
>
>
>
>
>
>extern double __strtod_internal (__const char *__restrict __nptr,
> char **__restrict __endptr, int __group)
> throw () __attribute__ ((__nonnull__ (1)));
>extern float __strtof_internal (__const char *__restrict __nptr,
> char **__restrict __endptr, int __group)
> throw () __attribute__ ((__nonnull__ (1)));
>extern long double __strtold_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __group) throw () __attribute__ ((__nonnull__ (1)));
>
>extern long int __strtol_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int __strtoll_internal (__const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>__extension__
>extern unsigned long long int __strtoull_internal (__const char *
> __restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1)));
># 424 "/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)));
>
>
>
>
># 1 "/usr/include/sys/types.h" 1 3 4
># 29 "/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;
># 57 "/usr/include/sys/types.h" 3 4
>typedef __ino64_t ino64_t;
># 105 "/usr/include/sys/types.h" 3 4
>typedef __id_t id_t;
># 116 "/usr/include/sys/types.h" 3 4
>typedef __daddr_t daddr_t;
>typedef __caddr_t caddr_t;
>
>
>
>
>
>typedef __key_t key_t;
># 141 "/usr/include/sys/types.h" 3 4
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 148 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 197 "/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__)));
># 216 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 32 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 35 "/usr/include/sys/select.h" 2 3 4
># 46 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/time.h" 1 3 4
># 69 "/usr/include/bits/time.h" 3 4
>struct timeval
> {
> __time_t tv_sec;
> __suseconds_t tv_usec;
> };
># 47 "/usr/include/sys/select.h" 2 3 4
># 55 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 67 "/usr/include/sys/select.h" 3 4
>typedef struct
> {
>
>
>
> __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];
>
>
>
>
>
> } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 99 "/usr/include/sys/select.h" 3 4
>extern "C" {
># 109 "/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);
># 121 "/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);
>
>
>}
># 217 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 29 "/usr/include/sys/sysmacros.h" 3 4
>__extension__
>extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
> throw ();
>__extension__
>extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
> throw ();
>__extension__
>extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
> unsigned int __minor)
> throw ();
>
>
>__extension__ extern __inline unsigned int
>gnu_dev_major (unsigned long long int __dev) throw ()
>{
> return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline unsigned int
>gnu_dev_minor (unsigned long long int __dev) throw ()
>{
> return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline unsigned long long int
>gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
>{
> return ((__minor & 0xff) | ((__major & 0xfff) << 8)
> | (((unsigned long long int) (__minor & ~0xff)) << 12)
> | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
># 220 "/usr/include/sys/types.h" 2 3 4
># 235 "/usr/include/sys/types.h" 3 4
>typedef __fsblkcnt_t fsblkcnt_t;
>
>
>
>typedef __fsfilcnt_t fsfilcnt_t;
># 258 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
>
>
>
>
>
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 267 "/usr/include/sys/types.h" 2 3 4
>
>
>}
># 434 "/usr/include/stdlib.h" 2 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__ ((__malloc__));
>
>extern void free (void *__ptr) throw ();
>
>
>
>
>extern void cfree (void *__ptr) throw ();
>
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 25 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 26 "/usr/include/alloca.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>extern void *alloca (size_t __size) throw ();
>
>
>
>
>
>}
># 607 "/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 abort (void) throw () __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) throw () __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 _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 ();
>
>
>
>
>
>
>extern int clearenv (void) throw ();
># 691 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
># 702 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1)));
># 711 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1)));
># 721 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>
>extern int system (__const char *__command);
>
>
>
>
>
>
>
>extern char *canonicalize_file_name (__const char *__name)
> throw () __attribute__ ((__nonnull__ (1)));
># 749 "/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;
>
>
>
>
>
>
>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 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__));
>
># 814 "/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)));
># 902 "/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)));
>
>
>
>
>
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 2 3
># 84 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 3
>namespace std
>{
> using ::div_t;
> using ::ldiv_t;
>
> using ::abort;
> using ::abs;
> using ::atexit;
> using ::atof;
> using ::atoi;
> using ::atol;
> using ::bsearch;
> using ::calloc;
> using ::div;
> using ::exit;
> using ::free;
> using ::getenv;
> using ::labs;
> using ::ldiv;
> using ::malloc;
>
> using ::mblen;
> using ::mbstowcs;
> using ::mbtowc;
>
> using ::qsort;
> using ::rand;
> using ::realloc;
> using ::srand;
> using ::strtod;
> using ::strtol;
> using ::strtoul;
> using ::system;
>
> using ::wcstombs;
> using ::wctomb;
>
>
> inline long
> abs(long __i) { return labs(__i); }
>
> inline ldiv_t
> div(long __i, long __j) { return ldiv(__i, __j); }
>}
># 140 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 3
>namespace __gnu_cxx
>{
>
> using ::lldiv_t;
>
>
>
>
>
> using ::_Exit;
>
>
> inline long long
> abs(long long __x) { return __x >= 0 ? __x : -__x; }
>
> inline long long
> llabs(long long __x) { return __x >= 0 ? __x : -__x; }
>
>
> inline lldiv_t
> div(long long __n, long long __d)
> { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
>
> inline lldiv_t
> lldiv(long long __n, long long __d)
> { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
># 176 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cstdlib" 3
> using ::atoll;
> using ::strtoll;
> using ::strtoull;
>
> using ::strtof;
> using ::strtold;
>}
>
>namespace std
>{
>
> using __gnu_cxx::lldiv_t;
>
> using __gnu_cxx::_Exit;
> using __gnu_cxx::abs;
> using __gnu_cxx::llabs;
>
> using __gnu_cxx::div;
> using __gnu_cxx::lldiv;
>
> using __gnu_cxx::atoll;
> using __gnu_cxx::strtof;
> using __gnu_cxx::strtoll;
> using __gnu_cxx::strtoull;
> using __gnu_cxx::strtold;
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/new" 1 3
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/new" 3
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
> class bad_alloc : public exception
> {
> public:
> bad_alloc() throw() { }
>
>
> virtual ~bad_alloc() throw();
> };
>
> struct nothrow_t { };
> extern const nothrow_t nothrow;
>
>
> typedef void (*new_handler)();
>
> new_handler set_new_handler(new_handler) throw();
>}
># 82 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/new" 3
>void* operator new(std::size_t) throw (std::bad_alloc);
>void* operator new[](std::size_t) throw (std::bad_alloc);
>void operator delete(void*) throw();
>void operator delete[](void*) throw();
>void* operator new(std::size_t, const std::nothrow_t&) throw();
>void* operator new[](std::size_t, const std::nothrow_t&) throw();
>void operator delete(void*, const std::nothrow_t&) throw();
>void operator delete[](void*, const std::nothrow_t&) throw();
>
>
>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() { }
>
>}
># 70 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_pair.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_pair.h" 3
>namespace std
>{
>
> 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) { }
> };
>
>
> 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); }
># 142 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
>}
># 72 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/type_traits.h" 1 3
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/type_traits.h" 3
> 
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/type_traits.h" 3
># 90 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/type_traits.h" 3
>struct __true_type {};
>struct __false_type {};
>
>template <class _Tp>
> struct __type_traits
> {
> typedef __true_type this_dummy_member_must_be_first;
># 114 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/type_traits.h" 3
> typedef __false_type has_trivial_default_constructor;
> typedef __false_type has_trivial_copy_constructor;
> typedef __false_type has_trivial_assignment_operator;
> typedef __false_type has_trivial_destructor;
> typedef __false_type is_POD_type;
> };
>
>
>
>
>template<>
> struct __type_traits<bool>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<char>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<signed char>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<unsigned char>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<wchar_t>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<short>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<unsigned short>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<int>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<unsigned int>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<long>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<unsigned long>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<long long>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<unsigned long long>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<float>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<double>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template<>
> struct __type_traits<long double>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>template <class _Tp>
> struct __type_traits<_Tp*>
> {
> typedef __true_type has_trivial_default_constructor;
> typedef __true_type has_trivial_copy_constructor;
> typedef __true_type has_trivial_assignment_operator;
> typedef __true_type has_trivial_destructor;
> typedef __true_type is_POD_type;
> };
>
>
>
>
>template <class _Tp>
> struct _Is_integer
> {
> typedef __false_type _Integral;
> };
>
>template<>
> struct _Is_integer<bool>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<char>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<signed char>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<unsigned char>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<wchar_t>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<short>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<unsigned short>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<int>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<unsigned int>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<long>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<unsigned long>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<long long>
> {
> typedef __true_type _Integral;
> };
>
>template<>
> struct _Is_integer<unsigned long long>
> {
> typedef __true_type _Integral;
> };
>
>template<typename _Tp>
> struct _Is_normal_iterator
> {
> typedef __false_type _Normal;
> };
>
>
>namespace __gnu_cxx
>{
> template<typename _Iterator, typename _Container>
> class __normal_iterator;
>}
>
>template<typename _Iterator, typename _Container>
> struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
> _Container> >
> {
> typedef __true_type _Normal;
> };
># 73 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_types.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_types.h" 3
> 
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_types.h" 3
>
>namespace std
>{
># 80 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 {};
># 104 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> };
>
>
>
>
>
>
>
> 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(); }
>
>}
># 74 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_funcs.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_funcs.h" 3
> 
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_funcs.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/concept_check.h" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/concept_check.h" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/concept_check.h" 3
># 69 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_funcs.h" 2 3
>
>namespace std
>{
> 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/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 170 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator, typename _Distance>
> inline void
> advance(_InputIterator& __i, _Distance __n)
> {
>
> std::__advance(__i, __n, std::__iterator_category(__i));
> }
>}
># 75 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 1 3
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 3
>namespace std
>{
># 89 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename iterator_traits<_Iterator>::difference_type
> difference_type;
> typedef typename iterator_traits<_Iterator>::reference reference;
> typedef typename iterator_traits<_Iterator>::pointer pointer;
>
> public:
>
>
>
>
>
>
> 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; }
>
>
>
>
>
>
> 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); }
> };
># 275 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 335 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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) { }
># 361 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 3
> back_insert_iterator&
> operator=(typename _Container::const_reference __value)
> {
> container->push_back(__value);
> return *this;
> }
>
>
> back_insert_iterator&
> operator*()
> { return *this; }
>
>
> back_insert_iterator&
> operator++()
> { return *this; }
>
>
> back_insert_iterator
> operator++(int)
> { return *this; }
> };
># 395 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 3
> template<typename _Container>
> inline back_insert_iterator<_Container>
> back_inserter(_Container& __x)
> { return back_insert_iterator<_Container>(__x); }
># 410 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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) { }
># 435 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 3
> front_insert_iterator&
> operator=(typename _Container::const_reference __value)
> {
> container->push_front(__value);
> return *this;
> }
>
>
> front_insert_iterator&
> operator*()
> { return *this; }
>
>
> front_insert_iterator&
> operator++()
> { return *this; }
>
>
> front_insert_iterator
> operator++(int)
> { return *this; }
> };
># 469 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 3
> template<typename _Container>
> inline front_insert_iterator<_Container>
> front_inserter(_Container& __x)
> { return front_insert_iterator<_Container>(__x); }
># 488 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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) {}
># 530 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_iterator.h" 3
> insert_iterator&
> operator=(const typename _Container::const_reference __value)
> {
> iter = container->insert(iter, __value);
> ++iter;
> return *this;
> }
>
>
> insert_iterator&
> operator*()
> { return *this; }
>
>
> insert_iterator&
> operator++()
> { return *this; }
>
>
> insert_iterator&
> operator++(int)
> { return *this; }
> };
># 565 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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
>{
>
>
>
>
>
>
>
> using std::iterator_traits;
> using std::iterator;
> template<typename _Iterator, typename _Container>
> class __normal_iterator
> {
> protected:
> _Iterator _M_current;
>
> public:
> typedef typename iterator_traits<_Iterator>::iterator_category
> iterator_category;
> typedef typename iterator_traits<_Iterator>::value_type value_type;
> typedef typename iterator_traits<_Iterator>::difference_type
> difference_type;
> typedef typename iterator_traits<_Iterator>::reference reference;
> typedef typename iterator_traits<_Iterator>::pointer pointer;
>
> __normal_iterator() : _M_current(_Iterator()) { }
>
> explicit
> __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
>
>
> template<typename _Iter>
> inline __normal_iterator(const __normal_iterator<_Iter,
> _Container>& __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; }
> };
># 678 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 __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); }
>}
># 76 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/debug/debug.h" 1 3
># 272 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/debug/debug.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 2 3
># 273 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/debug/debug.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 275 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/debug/debug.h" 2 3
>
>
>
>namespace __gnu_debug
>{
> template<typename _Iterator, typename _Sequence>
> class _Safe_iterator;
>
>
> inline bool
> __check_singular_aux(const void*) { return false; }
>
>
>
> template<typename _Iterator>
> inline bool
> __check_singular(_Iterator& __x)
> { return __gnu_debug::__check_singular_aux(&__x); }
>
>
> template<typename _Tp>
> inline bool
> __check_singular(const _Tp* __ptr)
> { return __ptr == 0; }
>
>
> template<typename _Iterator, typename _Sequence>
> inline bool
> __check_singular(const _Safe_iterator<_Iterator, _Sequence>& __x)
> { return __x._M_singular(); }
>
>
>
> template<typename _Iterator>
> inline bool
> __check_dereferenceable(_Iterator&)
> { return true; }
>
>
> template<typename _Tp>
> inline bool
> __check_dereferenceable(const _Tp* __ptr)
> { return __ptr; }
>
>
> template<typename _Iterator, typename _Sequence>
> inline bool
> __check_dereferenceable(const _Safe_iterator<_Iterator, _Sequence>& __x)
> { return __x._M_dereferenceable(); }
>
>
>
>
> template<typename _RandomAccessIterator>
> inline bool
> __valid_range_aux2(const _RandomAccessIterator& __first,
> const _RandomAccessIterator& __last,
> std::random_access_iterator_tag)
> { return __last - __first >= 0; }
>
>
>
>
>
> template<typename _InputIterator>
> inline bool
> __valid_range_aux2(const _InputIterator&, const _InputIterator&,
> std::input_iterator_tag)
> { return true; }
>
>
>
>
>
> template<typename _Integral>
> inline bool
> __valid_range_aux(const _Integral&, const _Integral&, __true_type)
> { return true; }
>
>
>
>
> template<typename _InputIterator>
> inline bool
> __valid_range_aux(const _InputIterator& __first,
> const _InputIterator& __last, __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::iterator_category
> _Category;
> return __gnu_debug::__valid_range_aux2(__first, __last, _Category());
> }
>
>
>
>
>
>
> template<typename _InputIterator>
> inline bool
> __valid_range(const _InputIterator& __first, const _InputIterator& __last)
> {
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> return __gnu_debug::__valid_range_aux(__first, __last, _Integral());
> }
>
>
> template<typename _Iterator, typename _Sequence>
> inline bool
> __valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first,
> const _Safe_iterator<_Iterator, _Sequence>& __last)
> { return __first._M_valid_range(__last); }
>
>
>
>
>
> template<typename _InputIterator>
> inline _InputIterator
> __check_valid_range(const _InputIterator& __first,
> const _InputIterator& __last)
> {
> ;
> return __first;
> }
>
>
> template<typename _CharT, typename _Integer>
> inline const _CharT*
> __check_string(const _CharT* __s, const _Integer& __n)
> {
>
>
>
> return __s;
> }
>
>
> template<typename _CharT>
> inline const _CharT*
> __check_string(const _CharT* __s)
> {
>
>
>
> return __s;
> }
>
>
>
> template<typename _InputIterator>
> inline bool
> __check_sorted_aux(const _InputIterator&, const _InputIterator&,
> std::input_iterator_tag)
> { return true; }
>
>
>
> template<typename _ForwardIterator>
> inline bool
> __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> if (__first == __last)
> return true;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, ++__next) {
> if (*__next < *__first)
> return false;
> }
>
> return true;
> }
>
>
>
> template<typename _InputIterator, typename _Predicate>
> inline bool
> __check_sorted_aux(const _InputIterator&, const _InputIterator&,
> _Predicate, std::input_iterator_tag)
> { return true; }
>
>
>
> template<typename _ForwardIterator, typename _Predicate>
> inline bool
> __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, std::forward_iterator_tag)
> {
> if (__first == __last)
> return true;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, ++__next) {
> if (__pred(*__next, *__first))
> return false;
> }
>
> return true;
> }
>
>
> template<typename _InputIterator>
> inline bool
> __check_sorted(const _InputIterator& __first, const _InputIterator& __last)
> {
> typedef typename std::iterator_traits<_InputIterator>::iterator_category
> _Category;
> return __gnu_debug::__check_sorted_aux(__first, __last, _Category());
> }
>
> template<typename _InputIterator, typename _Predicate>
> inline bool
> __check_sorted(const _InputIterator& __first, const _InputIterator& __last,
> _Predicate __pred)
> {
> typedef typename std::iterator_traits<_InputIterator>::iterator_category
> _Category;
> return __gnu_debug::__check_sorted_aux(__first, __last, __pred,
> _Category());
> }
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> inline bool
> __check_partitioned(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> while (__first != __last && *__first < __value)
> ++__first;
> while (__first != __last && !(*__first < __value))
> ++__first;
> return __first == __last;
> }
>
>
> template<typename _ForwardIterator, typename _Tp, typename _Pred>
> inline bool
> __check_partitioned(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value, _Pred __pred)
> {
> while (__first != __last && __pred(*__first, __value))
> ++__first;
> while (__first != __last && !__pred(*__first, __value))
> ++__first;
> return __first == __last;
> }
>}
># 78 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 2 3
>
>namespace std
>{
># 90 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
>
> 
>
> 
>
> 
>
> 
>
>
> const _ValueType1 __tmp = *__a;
> *__a = *__b;
> *__b = __tmp;
> }
># 123 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline void
> swap(_Tp& __a, _Tp& __b)
> {
>
> 
>
> const _Tp __tmp = __a;
> __a = __b;
> __b = __tmp;
> }
># 148 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 170 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 192 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 212 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, input_iterator_tag)
> {
> for (; __first != __last; ++__result, ++__first)
> *__result = *__first;
> return __result;
> }
>
> template<typename _RandomAccessIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _OutputIterator __result, random_access_iterator_tag)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> for (_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = *__first;
> ++__first;
> ++__result;
> }
> return __result;
> }
>
> template<typename _Tp>
> inline _Tp*
> __copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> std::memmove(__result, __first, sizeof(_Tp) * (__last - __first));
> return __result + (__last - __first);
> }
>
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy_aux2(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, __false_type)
> { return std::__copy(__first, __last, __result,
> std::__iterator_category(__first)); }
>
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy_aux2(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, __true_type)
> { return std::__copy(__first, __last, __result,
> std::__iterator_category(__first)); }
>
> template<typename _Tp>
> inline _Tp*
> __copy_aux2(_Tp* __first, _Tp* __last, _Tp* __result, __true_type)
> { return std::__copy_trivial(__first, __last, __result); }
>
> template<typename _Tp>
> inline _Tp*
> __copy_aux2(const _Tp* __first, const _Tp* __last, _Tp* __result,
> __true_type)
> { return std::__copy_trivial(__first, __last, __result); }
>
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy_ni2(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, __true_type)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _ValueType;
> typedef typename __type_traits<
> _ValueType>::has_trivial_assignment_operator _Trivial;
> return _OutputIterator(std::__copy_aux2(__first, __last, __result.base(),
> _Trivial()));
> }
>
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy_ni2(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, __false_type)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
> typedef typename __type_traits<
> _ValueType>::has_trivial_assignment_operator _Trivial;
> return std::__copy_aux2(__first, __last, __result, _Trivial());
> }
>
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy_ni1(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, __true_type)
> {
> typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
> return std::__copy_ni2(__first.base(), __last.base(),
> __result, __Normal());
> }
>
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> __copy_ni1(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, __false_type)
> {
> typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
> return std::__copy_ni2(__first, __last, __result, __Normal());
> }
># 346 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> ;
>
> typedef typename _Is_normal_iterator<_InputIterator>::_Normal __Normal;
> return std::__copy_ni1(__first, __last, __result, __Normal());
> }
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
> inline _BidirectionalIterator2
> __copy_backward(_BidirectionalIterator1 __first,
> _BidirectionalIterator1 __last,
> _BidirectionalIterator2 __result,
> bidirectional_iterator_tag)
> {
> while (__first != __last)
> *--__result = *--__last;
> return __result;
> }
>
> template<typename _RandomAccessIterator, typename _BidirectionalIterator>
> inline _BidirectionalIterator
> __copy_backward(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _BidirectionalIterator __result, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = *--__last;
> return __result;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BoolType>
> struct __copy_backward_dispatch
> {
> static _BidirectionalIterator2
> copy(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
> _BidirectionalIterator2 __result)
> { return std::__copy_backward(__first, __last, __result,
> std::__iterator_category(__first)); }
> };
>
> template<typename _Tp>
> struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
> {
> static _Tp*
> copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> const ptrdiff_t _Num = __last - __first;
> std::memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
> return __result - _Num;
> }
> };
>
> template<typename _Tp>
> struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
> {
> static _Tp*
> copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> return std::__copy_backward_dispatch<_Tp*, _Tp*, __true_type>
> ::copy(__first, __last, __result);
> }
> };
>
> template<typename _BI1, typename _BI2>
> inline _BI2
> __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
> ::has_trivial_assignment_operator _Trivial;
> return
> std::__copy_backward_dispatch<_BI1, _BI2, _Trivial>::copy(__first,
> __last,
> __result);
> }
>
> template <typename _BI1, typename _BI2>
> inline _BI2
> __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
> _BI2 __result, __true_type)
> { return _BI2(std::__copy_backward_aux(__first, __last, __result.base())); }
>
> template <typename _BI1, typename _BI2>
> inline _BI2
> __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
> _BI2 __result, __false_type)
> { return std::__copy_backward_aux(__first, __last, __result); }
>
> template <typename _BI1, typename _BI2>
> inline _BI2
> __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
> _BI2 __result, __true_type)
> {
> typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
> return std::__copy_backward_output_normal_iterator(__first.base(),
> __last.base(),
> __result, __Normal());
> }
>
> template <typename _BI1, typename _BI2>
> inline _BI2
> __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
> _BI2 __result, __false_type)
> {
> typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
> return std::__copy_backward_output_normal_iterator(__first, __last,
> __result, __Normal());
> }
># 485 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template <typename _BI1, typename _BI2>
> inline _BI2
> copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
> return std::__copy_backward_input_normal_iterator(__first, __last,
> __result, __Normal());
> }
># 514 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
> {
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> *__first = __value;
> }
># 538 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _OutputIterator, typename _Size, typename _Tp>
> _OutputIterator
> fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
>
> 
>
> for ( ; __n > 0; --__n, ++__first)
> *__first = __value;
> return __first;
> }
>
>
> inline void
> fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
> {
> ;
> const unsigned char __tmp = __c;
> std::memset(__first, __tmp, __last - __first);
> }
>
> inline void
> fill(signed char* __first, signed char* __last, const signed char& __c)
> {
> ;
> const signed char __tmp = __c;
> std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
> }
>
> inline void
> fill(char* __first, char* __last, const char& __c)
> {
> ;
> const char __tmp = __c;
> std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
> }
>
> template<typename _Size>
> inline unsigned char*
> fill_n(unsigned char* __first, _Size __n, const unsigned char& __c)
> {
> std::fill(__first, __first + __n, __c);
> return __first + __n;
> }
>
> template<typename _Size>
> inline signed char*
> fill_n(char* __first, _Size __n, const signed char& __c)
> {
> std::fill(__first, __first + __n, __c);
> return __first + __n;
> }
>
> template<typename _Size>
> inline char*
> fill_n(char* __first, _Size __n, const char& __c)
> {
> std::fill(__first, __first + __n, __c);
> return __first + __n;
> }
># 612 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
> }
># 647 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 && __binary_pred(*__first1, *__first2))
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 677 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> inline bool
> equal(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> for ( ; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> return false;
> return true;
> }
># 709 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> inline bool
> equal(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> for ( ; __first1 != __last1; ++__first1, ++__first2)
> if (!__binary_pred(*__first1, *__first2))
> return false;
> return true;
> }
># 741 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> bool
> lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
>
> 
> 
> 
>
>
> 
>
>
> ;
> ;
>
> for (;__first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
> {
> if (*__first1 < *__first2)
> return true;
> if (*__first2 < *__first1)
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
># 780 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _Compare __comp)
> {
>
> 
> 
> ;
> ;
>
> for ( ; __first1 != __last1 && __first2 != __last2
> ; ++__first1, ++__first2)
> {
> if (__comp(*__first1, *__first2))
> return true;
> if (__comp(*__first2, *__first1))
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
>
> inline bool
> lexicographical_compare(const unsigned char* __first1,
> const unsigned char* __last1,
> const unsigned char* __first2,
> const unsigned char* __last2)
> {
> ;
> ;
>
> const size_t __len1 = __last1 - __first1;
> const size_t __len2 = __last2 - __first2;
> const int __result = std::memcmp(__first1, __first2,
> std::min(__len1, __len2));
> return __result != 0 ? __result < 0 : __len1 < __len2;
> }
>
> inline bool
> lexicographical_compare(const char* __first1, const char* __last1,
> const char* __first2, const char* __last2)
> {
> ;
> ;
>
>
> return std::lexicographical_compare((const signed char*) __first1,
> (const signed char*) __last1,
> (const signed char*) __first2,
> (const signed char*) __last2);
>
>
>
>
>
>
> }
>
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/char_traits.h" 2 3
>
>
>namespace __gnu_cxx
>{
># 62 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/char_traits.h" 3
> template <class _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;
> };
># 86 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 (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*>(std::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
>{
># 224 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 memcmp(__s1, __s2, __n); }
>
> static size_t
> length(const char_type* __s)
> { return strlen(__s); }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> { return static_cast<const char_type*>(memchr(__s, __a, __n)); }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> { return static_cast<char_type*>(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; }
> };
>
>
> template<typename _CharT, typename _Traits>
> struct _Char_traits_match
> {
> _CharT _M_c;
> _Char_traits_match(_CharT const& __c) : _M_c(__c) { }
>
> bool
> operator()(_CharT const& __a) { return _Traits::eq(_M_c, __a); }
> };
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/localefwd.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/localefwd.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/localefwd.h" 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 3
>namespace std
>{
>
> void
> __throw_bad_exception(void);
>
>
> void
> __throw_bad_alloc(void);
>
>
> void
> __throw_bad_cast(void);
>
> void
> __throw_bad_typeid(void);
>
>
> void
> __throw_logic_error(const char* __s);
>
> void
> __throw_domain_error(const char* __s);
>
> void
> __throw_invalid_argument(const char* __s);
>
> void
> __throw_length_error(const char* __s);
>
> void
> __throw_out_of_range(const char* __s);
>
> void
> __throw_runtime_error(const char* __s);
>
> void
> __throw_range_error(const char* __s);
>
> void
> __throw_overflow_error(const char* __s);
>
> void
> __throw_underflow_error(const char* __s);
>
>
> void
> __throw_ios_failure(const char* __s);
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/localefwd.h" 2 3
>
>namespace std
>{
>
> class locale;
>
>
> template<typename _CharT>
> inline bool
> isspace(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isprint(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> iscntrl(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isupper(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> islower(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isalpha(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isdigit(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> ispunct(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isxdigit(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isalnum(_CharT, const locale&);
>
> template<typename _CharT>
> inline bool
> isgraph(_CharT, const locale&);
>
> template<typename _CharT>
> inline _CharT
> toupper(_CharT, const locale&);
>
> template<typename _CharT>
> inline _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;
> class __enc_traits;
> 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;
>
> template<typename _Facet>
> bool
> has_facet(const locale& __loc) throw();
>
> template<typename _Facet>
> const _Facet&
> use_facet(const locale& __loc);
>
> template<typename _Facet>
> inline const _Facet&
> __check_facet(const _Facet* __f)
> {
> if (!__f)
> __throw_bad_cast();
> return *__f;
> }
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/atomicity.h" 1 3
># 33 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/atomicity.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/atomic_word.h" 1 3
># 33 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/atomic_word.h" 3
>typedef int _Atomic_word;
># 34 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/atomicity.h" 2 3
>
>namespace __gnu_cxx
>{
> _Atomic_word
> __attribute__ ((__unused__))
> __exchange_and_add(volatile _Atomic_word* __mem, int __val);
>
> void
> __attribute__ ((__unused__))
> __atomic_add(volatile _Atomic_word* __mem, int __val);
>}
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 1 3
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> 
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/allocator.h" 1 3
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/allocator.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++allocator.h" 1 3
># 34 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++allocator.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ext/new_allocator.h" 1 3
># 35 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ext/new_allocator.h" 3
>namespace __gnu_cxx
>{
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 &__x; }
>
> const_pointer
> address(const_reference __x) const { return &__x; }
>
>
>
> pointer
> allocate(size_type __n, const void* = 0)
> { 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); }
>
>
>
> void
> construct(pointer __p, const _Tp& __val)
> { ::new(__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; }
>}
># 35 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/c++allocator.h" 2 3
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/allocator.h" 2 3
>
>namespace std
>{
> template<typename _Tp>
> class allocator;
>
> 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; };
> };
>
>
>
>
>
>
> 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 _T1, typename _T2>
> inline bool
> operator!=(const allocator<_T1>&, const allocator<_T2>&)
> { return false; }
>
>
>
>
>
> extern template class allocator<char>;
> extern template class allocator<wchar_t>;
>
>
>
>
>}
># 56 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_construct.h" 1 3
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_construct.h" 3
>namespace std
>{
>
>
>
>
>
>
> template<typename _T1, typename _T2>
> inline void
> _Construct(_T1* __p, const _T2& __value)
> {
>
>
> ::new(static_cast<void*>(__p)) _T1(__value);
> }
>
>
>
>
>
>
>
> template<typename _T1>
> inline void
> _Construct(_T1* __p)
> {
>
>
> ::new(static_cast<void*>(__p)) _T1();
> }
>
>
>
>
>
>
> template<typename _Tp>
> inline void
> _Destroy(_Tp* __pointer)
> { __pointer->~_Tp(); }
># 116 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_construct.h" 3
> template<typename _ForwardIterator>
> inline void
> __destroy_aux(_ForwardIterator __first, _ForwardIterator __last,
> __false_type)
> { for ( ; __first != __last; ++__first) std::_Destroy(&*__first); }
># 131 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_construct.h" 3
> template<typename _ForwardIterator>
> inline void
> __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type)
> { }
># 143 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_construct.h" 3
> template<typename _ForwardIterator>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _Value_type;
> typedef typename __type_traits<_Value_type>::has_trivial_destructor
> _Has_trivial_destructor;
>
> std::__destroy_aux(__first, __last, _Has_trivial_destructor());
> }
>}
># 57 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_uninitialized.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_uninitialized.h" 3
>namespace std
>{
>
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> __true_type)
> { return std::copy(__first, __last, __result); }
>
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> __false_type)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for ( ; __first != __last; ++__first, ++__cur)
> std::_Construct(&*__cur, *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
># 105 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
> typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
> return std::__uninitialized_copy_aux(__first, __last, __result,
> _Is_POD());
> }
>
> inline char*
> uninitialized_copy(const char* __first, const char* __last, char* __result)
> {
> std::memmove(__result, __first, __last - __first);
> return __result + (__last - __first);
> }
>
> inline wchar_t*
> uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
> wchar_t* __result)
> {
> std::memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
> return __result + (__last - __first);
> }
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_fill_aux(_ForwardIterator __first,
> _ForwardIterator __last,
> const _Tp& __x, __true_type)
> { std::fill(__first, __last, __x); }
>
> template<typename _ForwardIterator, typename _Tp>
> void
> __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, __false_type)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for ( ; __cur != __last; ++__cur)
> std::_Construct(&*__cur, __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
># 167 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
> std::__uninitialized_fill_aux(__first, __last, __x, _Is_POD());
> }
>
>
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline _ForwardIterator
> __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
> const _Tp& __x, __true_type)
> { return std::fill_n(__first, __n, __x); }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> _ForwardIterator
> __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
> const _Tp& __x, __false_type)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for ( ; __n > 0; --__n, ++__cur)
> std::_Construct(&*__cur, __x);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
># 213 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline _ForwardIterator
> uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
> typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
> return std::__uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
> }
># 230 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_uninitialized.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_copy(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result)
> {
> _ForwardIterator __mid = std::uninitialized_copy(__first1, __last1,
> __result);
> try
> {
> return std::uninitialized_copy(__first2, __last2, __mid);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid);
> throw;
> }
> }
>
>
>
>
> template<typename _ForwardIterator, typename _Tp, typename _InputIterator>
> inline _ForwardIterator
> __uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
> const _Tp& __x, _InputIterator __first,
> _InputIterator __last)
> {
> std::uninitialized_fill(__result, __mid, __x);
> try
> {
> return std::uninitialized_copy(__first, __last, __mid);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid);
> throw;
> }
> }
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2,
> _ForwardIterator __last2, const _Tp& __x)
> {
> _ForwardIterator __mid2 = std::uninitialized_copy(__first1, __last1,
> __first2);
> try
> {
> std::uninitialized_fill(__mid2, __last2, __x);
> }
> catch(...)
> {
> std::_Destroy(__first2, __mid2);
> throw;
> }
> }
>
>}
># 59 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_raw_storage_iter.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_raw_storage_iter.h" 3
>namespace std
>{
>
>
>
>
> template <class _ForwardIterator, class _Tp>
> class raw_storage_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _ForwardIterator _M_iter;
>
> public:
> explicit
> raw_storage_iterator(_ForwardIterator __x)
> : _M_iter(__x) {}
>
> raw_storage_iterator&
> operator*() { return *this; }
>
> raw_storage_iterator&
> operator=(const _Tp& __element)
> {
> std::_Construct(&*_M_iter, __element);
> return *this;
> }
>
> raw_storage_iterator<_ForwardIterator, _Tp>&
> operator++()
> {
> ++_M_iter;
> return *this;
> }
>
> raw_storage_iterator<_ForwardIterator, _Tp>
> operator++(int)
> {
> raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
> ++_M_iter;
> return __tmp;
> }
> };
>}
># 60 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 2 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/limits" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/limits" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/limits" 3
># 150 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/limits" 3
>namespace std
>{
>
>
>
>
>
> enum float_round_style
> {
> round_indeterminate = -1,
> round_toward_zero = 0,
> round_to_nearest = 1,
> round_toward_infinity = 2,
> round_toward_neg_infinity = 3
> };
>
>
>
>
>
>
>
> enum float_denorm_style
> {
>
> denorm_indeterminate = -1,
>
> denorm_absent = 0,
>
> denorm_present = 1
> };
># 192 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/limits" 3
> struct __numeric_limits_base
> {
>
>
> static const bool is_specialized = false;
>
>
>
>
> static const int digits = 0;
>
> static const int digits10 = 0;
>
> static const bool is_signed = false;
>
>
>
>
>
> static const bool is_integer = false;
>
>
>
>
> static const bool is_exact = false;
>
>
> static const int radix = 0;
>
>
>
> static const int min_exponent = 0;
>
>
> static const int min_exponent10 = 0;
>
>
>
> static const int max_exponent = 0;
>
>
> static const int max_exponent10 = 0;
>
>
> static const bool has_infinity = false;
>
>
> static const bool has_quiet_NaN = false;
>
>
> static const bool has_signaling_NaN = false;
>
> static const float_denorm_style has_denorm = denorm_absent;
>
>
> static const bool has_denorm_loss = false;
>
>
>
> static const bool is_iec559 = false;
>
>
>
> static const bool is_bounded = false;
>
>
>
>
> static const bool is_modulo = false;
>
>
> static const bool traps = false;
>
> static const bool tinyness_before = false;
>
>
>
> static const float_round_style round_style = round_toward_zero;
> };
># 285 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/limits" 3
> template<typename _Tp>
> struct numeric_limits : public __numeric_limits_base
> {
>
>
> static _Tp min() throw() { return static_cast<_Tp>(0); }
>
> static _Tp max() throw() { return static_cast<_Tp>(0); }
>
>
> static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
>
> static _Tp round_error() throw() { return static_cast<_Tp>(0); }
>
> static _Tp infinity() throw() { return static_cast<_Tp>(0); }
>
> static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
>
>
> static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
>
>
>
> static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
> };
>
>
>
> template<>
> struct numeric_limits<bool>
> {
> static const bool is_specialized = true;
>
> static bool min() throw()
> { return false; }
> static bool max() throw()
> { return true; }
>
> static const int digits = 1;
> static const int digits10 = 0;
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static bool epsilon() throw()
> { return false; }
> static bool round_error() throw()
> { return false; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static bool infinity() throw()
> { return false; }
> static bool quiet_NaN() throw()
> { return false; }
> static bool signaling_NaN() throw()
> { return false; }
> static bool denorm_min() throw()
> { return false; }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
>
>
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<char>
> {
> static const bool is_specialized = true;
>
> static char min() throw()
> { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
> static char max() throw()
> { return (((char)(-1) < 0) ? ((char)1 << (sizeof(char) * 8 - ((char)(-1) < 0))) - 1 : ~(char)0); }
>
> static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
> static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = ((char)(-1) < 0);
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static char epsilon() throw()
> { return 0; }
> static char round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static char infinity() throw()
> { return char(); }
> static char quiet_NaN() throw()
> { return char(); }
> static char signaling_NaN() throw()
> { return char(); }
> static char denorm_min() throw()
> { return static_cast<char>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<signed char>
> {
> static const bool is_specialized = true;
>
> static signed char min() throw()
> { return -127 - 1; }
> static signed char max() throw()
> { return 127; }
>
> static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
> static const int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static signed char epsilon() throw()
> { return 0; }
> static signed char round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static signed char infinity() throw()
> { return static_cast<signed char>(0); }
> static signed char quiet_NaN() throw()
> { return static_cast<signed char>(0); }
> static signed char signaling_NaN() throw()
> { return static_cast<signed char>(0); }
> static signed char denorm_min() throw()
> { return static_cast<signed char>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<unsigned char>
> {
> static const bool is_specialized = true;
>
> static unsigned char min() throw()
> { return 0; }
> static unsigned char max() throw()
> { return 127 * 2U + 1; }
>
> static const int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned char epsilon() throw()
> { return 0; }
> static unsigned char round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned char infinity() throw()
> { return static_cast<unsigned char>(0); }
> static unsigned char quiet_NaN() throw()
> { return static_cast<unsigned char>(0); }
> static unsigned char signaling_NaN() throw()
> { return static_cast<unsigned char>(0); }
> static unsigned char denorm_min() throw()
> { return static_cast<unsigned char>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<wchar_t>
> {
> static const bool is_specialized = true;
>
> static wchar_t min() throw()
> { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
> static wchar_t max() throw()
> { return (((wchar_t)(-1) < 0) ? ((wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0))) - 1 : ~(wchar_t)0); }
>
> static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
> static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = ((wchar_t)(-1) < 0);
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static wchar_t epsilon() throw()
> { return 0; }
> static wchar_t round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static wchar_t infinity() throw()
> { return wchar_t(); }
> static wchar_t quiet_NaN() throw()
> { return wchar_t(); }
> static wchar_t signaling_NaN() throw()
> { return wchar_t(); }
> static wchar_t denorm_min() throw()
> { return wchar_t(); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<short>
> {
> static const bool is_specialized = true;
>
> static short min() throw()
> { return -32767 - 1; }
> static short max() throw()
> { return 32767; }
>
> static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
> static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static short epsilon() throw()
> { return 0; }
> static short round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static short infinity() throw()
> { return short(); }
> static short quiet_NaN() throw()
> { return short(); }
> static short signaling_NaN() throw()
> { return short(); }
> static short denorm_min() throw()
> { return short(); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<unsigned short>
> {
> static const bool is_specialized = true;
>
> static unsigned short min() throw()
> { return 0; }
> static unsigned short max() throw()
> { return 32767 * 2U + 1; }
>
> static const int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned short epsilon() throw()
> { return 0; }
> static unsigned short round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned short infinity() throw()
> { return static_cast<unsigned short>(0); }
> static unsigned short quiet_NaN() throw()
> { return static_cast<unsigned short>(0); }
> static unsigned short signaling_NaN() throw()
> { return static_cast<unsigned short>(0); }
> static unsigned short denorm_min() throw()
> { return static_cast<unsigned short>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<int>
> {
> static const bool is_specialized = true;
>
> static int min() throw()
> { return -2147483647 - 1; }
> static int max() throw()
> { return 2147483647; }
>
> static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
> static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static int epsilon() throw()
> { return 0; }
> static int round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static int infinity() throw()
> { return static_cast<int>(0); }
> static int quiet_NaN() throw()
> { return static_cast<int>(0); }
> static int signaling_NaN() throw()
> { return static_cast<int>(0); }
> static int denorm_min() throw()
> { return static_cast<int>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<unsigned int>
> {
> static const bool is_specialized = true;
>
> static unsigned int min() throw()
> { return 0; }
> static unsigned int max() throw()
> { return 2147483647 * 2U + 1; }
>
> static const int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned int epsilon() throw()
> { return 0; }
> static unsigned int round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned int infinity() throw()
> { return static_cast<unsigned int>(0); }
> static unsigned int quiet_NaN() throw()
> { return static_cast<unsigned int>(0); }
> static unsigned int signaling_NaN() throw()
> { return static_cast<unsigned int>(0); }
> static unsigned int denorm_min() throw()
> { return static_cast<unsigned int>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<long>
> {
> static const bool is_specialized = true;
>
> static long min() throw()
> { return -2147483647L - 1; }
> static long max() throw()
> { return 2147483647L; }
>
> static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
> static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static long epsilon() throw()
> { return 0; }
> static long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static long infinity() throw()
> { return static_cast<long>(0); }
> static long quiet_NaN() throw()
> { return static_cast<long>(0); }
> static long signaling_NaN() throw()
> { return static_cast<long>(0); }
> static long denorm_min() throw()
> { return static_cast<long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<unsigned long>
> {
> static const bool is_specialized = true;
>
> static unsigned long min() throw()
> { return 0; }
> static unsigned long max() throw()
> { return 2147483647L * 2UL + 1; }
>
> static const int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned long epsilon() throw()
> { return 0; }
> static unsigned long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned long infinity() throw()
> { return static_cast<unsigned long>(0); }
> static unsigned long quiet_NaN() throw()
> { return static_cast<unsigned long>(0); }
> static unsigned long signaling_NaN() throw()
> { return static_cast<unsigned long>(0); }
> static unsigned long denorm_min() throw()
> { return static_cast<unsigned long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<long long>
> {
> static const bool is_specialized = true;
>
> static long long min() throw()
> { return -9223372036854775807LL - 1; }
> static long long max() throw()
> { return 9223372036854775807LL; }
>
> static const int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0));
> static const int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = true;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static long long epsilon() throw()
> { return 0; }
> static long long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static long long infinity() throw()
> { return static_cast<long long>(0); }
> static long long quiet_NaN() throw()
> { return static_cast<long long>(0); }
> static long long signaling_NaN() throw()
> { return static_cast<long long>(0); }
> static long long denorm_min() throw()
> { return static_cast<long long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<unsigned long long>
> {
> static const bool is_specialized = true;
>
> static unsigned long long min() throw()
> { return 0; }
> static unsigned long long max() throw()
> { return 9223372036854775807LL * 2ULL + 1; }
>
> static const int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
> static const int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643 / 2136);
> static const bool is_signed = false;
> static const bool is_integer = true;
> static const bool is_exact = true;
> static const int radix = 2;
> static unsigned long long epsilon() throw()
> { return 0; }
> static unsigned long long round_error() throw()
> { return 0; }
>
> static const int min_exponent = 0;
> static const int min_exponent10 = 0;
> static const int max_exponent = 0;
> static const int max_exponent10 = 0;
>
> static const bool has_infinity = false;
> static const bool has_quiet_NaN = false;
> static const bool has_signaling_NaN = false;
> static const float_denorm_style has_denorm = denorm_absent;
> static const bool has_denorm_loss = false;
>
> static unsigned long long infinity() throw()
> { return static_cast<unsigned long long>(0); }
> static unsigned long long quiet_NaN() throw()
> { return static_cast<unsigned long long>(0); }
> static unsigned long long signaling_NaN() throw()
> { return static_cast<unsigned long long>(0); }
> static unsigned long long denorm_min() throw()
> { return static_cast<unsigned long long>(0); }
>
> static const bool is_iec559 = false;
> static const bool is_bounded = true;
> static const bool is_modulo = true;
>
> static const bool traps = true;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_toward_zero;
> };
>
> template<>
> struct numeric_limits<float>
> {
> static const bool is_specialized = true;
>
> static float min() throw()
> { return 1.17549435e-38F; }
> static float max() throw()
> { return 3.40282347e+38F; }
>
> static const int digits = 24;
> static const int digits10 = 6;
> static const bool is_signed = true;
> static const bool is_integer = false;
> static const bool is_exact = false;
> static const int radix = 2;
> static float epsilon() throw()
> { return 1.19209290e-7F; }
> static float round_error() throw()
> { return 0.5F; }
>
> static const int min_exponent = (-125);
> static const int min_exponent10 = (-37);
> static const int max_exponent = 128;
> static const int max_exponent10 = 38;
>
> static const bool has_infinity = 1;
> static const bool has_quiet_NaN = 1;
> static const bool has_signaling_NaN = has_quiet_NaN;
> static const float_denorm_style has_denorm
> = bool(1.40129846e-45F) ? denorm_present : denorm_absent;
> static const bool has_denorm_loss = false;
>
> static float infinity() throw()
> { return __builtin_huge_valf (); }
> static float quiet_NaN() throw()
> { return __builtin_nanf (""); }
> static float signaling_NaN() throw()
> { return __builtin_nansf (""); }
> static float denorm_min() throw()
> { return 1.40129846e-45F; }
>
> static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
> static const bool traps = false;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_to_nearest;
> };
>
>
>
>
>
> template<>
> struct numeric_limits<double>
> {
> static const bool is_specialized = true;
>
> static double min() throw()
> { return 2.2250738585072014e-308; }
> static double max() throw()
> { return 1.7976931348623157e+308; }
>
> static const int digits = 53;
> static const int digits10 = 15;
> static const bool is_signed = true;
> static const bool is_integer = false;
> static const bool is_exact = false;
> static const int radix = 2;
> static double epsilon() throw()
> { return 2.2204460492503131e-16; }
> static double round_error() throw()
> { return 0.5; }
>
> static const int min_exponent = (-1021);
> static const int min_exponent10 = (-307);
> static const int max_exponent = 1024;
> static const int max_exponent10 = 308;
>
> static const bool has_infinity = 1;
> static const bool has_quiet_NaN = 1;
> static const bool has_signaling_NaN = has_quiet_NaN;
> static const float_denorm_style has_denorm
> = bool(4.9406564584124654e-324) ? denorm_present : denorm_absent;
> static const bool has_denorm_loss = false;
>
> static double infinity() throw()
> { return __builtin_huge_val(); }
> static double quiet_NaN() throw()
> { return __builtin_nan (""); }
> static double signaling_NaN() throw()
> { return __builtin_nans (""); }
> static double denorm_min() throw()
> { return 4.9406564584124654e-324; }
>
> static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
> static const bool traps = false;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_to_nearest;
> };
>
>
>
>
>
> template<>
> struct numeric_limits<long double>
> {
> static const bool is_specialized = true;
>
> static long double min() throw()
> { return 3.36210314311209350626e-4932L; }
> static long double max() throw()
> { return 1.18973149535723176502e+4932L; }
>
> static const int digits = 64;
> static const int digits10 = 18;
> static const bool is_signed = true;
> static const bool is_integer = false;
> static const bool is_exact = false;
> static const int radix = 2;
> static long double epsilon() throw()
> { return 1.08420217248550443401e-19L; }
> static long double round_error() throw()
> { return 0.5L; }
>
> static const int min_exponent = (-16381);
> static const int min_exponent10 = (-4931);
> static const int max_exponent = 16384;
> static const int max_exponent10 = 4932;
>
> static const bool has_infinity = 1;
> static const bool has_quiet_NaN = 1;
> static const bool has_signaling_NaN = has_quiet_NaN;
> static const float_denorm_style has_denorm
> = bool(3.64519953188247460253e-4951L) ? denorm_present : denorm_absent;
> static const bool has_denorm_loss
> = false;
>
> static long double infinity() throw()
> { return __builtin_huge_vall (); }
> static long double quiet_NaN() throw()
> { return __builtin_nanl (""); }
> static long double signaling_NaN() throw()
> { return __builtin_nansl (""); }
> static long double denorm_min() throw()
> { return 3.64519953188247460253e-4951L; }
>
> static const bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static const bool is_bounded = true;
> static const bool is_modulo = false;
>
> static const bool traps = false;
> static const bool tinyness_before = false;
> static const float_round_style round_style = round_to_nearest;
> };
>
>
>
>
>
>}
># 62 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 2 3
>
>namespace std
>{
># 73 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp>
> pair<_Tp*, ptrdiff_t>
> __get_temporary_buffer(ptrdiff_t __len, _Tp*)
> {
> const ptrdiff_t __max = numeric_limits<ptrdiff_t>::max() / sizeof(_Tp);
> if (__len > __max)
> __len = __max;
>
> while (__len > 0)
> {
> _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
> nothrow));
> if (__tmp != 0)
> return pair<_Tp*, ptrdiff_t>(__tmp, __len);
> __len /= 2;
> }
> return pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
> }
># 109 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp>
> inline pair<_Tp*, ptrdiff_t>
> get_temporary_buffer(ptrdiff_t __len)
> { return std::__get_temporary_buffer(__len, static_cast<_Tp*>(0)); }
># 121 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp>
> void
> return_temporary_buffer(_Tp* __p)
> { ::operator delete(__p, nothrow); }
># 133 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp1>
> struct auto_ptr_ref
> {
> _Tp1* _M_ptr;
>
> explicit
> auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
> };
># 174 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp>
> class auto_ptr
> {
> private:
> _Tp* _M_ptr;
>
> public:
>
> typedef _Tp element_type;
>
>
>
>
>
>
>
> explicit
> auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
># 200 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
># 212 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp1>
> auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
># 223 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> auto_ptr&
> operator=(auto_ptr& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 240 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> template<typename _Tp1>
> auto_ptr&
> operator=(auto_ptr<_Tp1>& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 260 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> ~auto_ptr() { delete _M_ptr; }
># 270 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> element_type&
> operator*() const throw()
> {
> ;
> return *_M_ptr;
> }
>
>
>
>
>
>
>
> element_type*
> operator->() const throw()
> {
> ;
> return _M_ptr;
> }
># 300 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> element_type*
> get() const throw() { return _M_ptr; }
># 314 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> element_type*
> release() throw()
> {
> element_type* __tmp = _M_ptr;
> _M_ptr = 0;
> return __tmp;
> }
># 329 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> void
> reset(element_type* __p = 0) throw()
> {
> if (__p != _M_ptr)
> {
> delete _M_ptr;
> _M_ptr = __p;
> }
> }
># 350 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/memory" 3
> auto_ptr(auto_ptr_ref<element_type> __ref) throw()
> : _M_ptr(__ref._M_ptr) { }
>
> auto_ptr&
> operator=(auto_ptr_ref<element_type> __ref) throw()
> {
> if (__ref._M_ptr != this->get())
> {
> delete _M_ptr;
> _M_ptr = __ref._M_ptr;
> }
> return *this;
> }
>
> template<typename _Tp1>
> operator auto_ptr_ref<_Tp1>() throw()
> { return auto_ptr_ref<_Tp1>(this->release()); }
>
> template<typename _Tp1>
> operator auto_ptr<_Tp1>() throw()
> { return auto_ptr<_Tp1>(this->release()); }
>
> };
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 2 3
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
>namespace std
>{
># 101 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _Arg, class _Result>
> struct unary_function
> {
> typedef _Arg argument_type;
>
>
> typedef _Result result_type;
> };
>
>
>
>
> template <class _Arg1, class _Arg2, class _Result>
> struct binary_function
> {
> typedef _Arg1 first_argument_type;
>
>
> typedef _Arg2 second_argument_type;
> typedef _Result result_type;
> };
># 133 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _Tp>
> struct plus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x + __y; }
> };
>
>
> template <class _Tp>
> struct minus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x - __y; }
> };
>
>
> template <class _Tp>
> struct multiplies : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x * __y; }
> };
>
>
> template <class _Tp>
> struct divides : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x / __y; }
> };
>
>
> template <class _Tp>
> struct modulus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x % __y; }
> };
>
>
> template <class _Tp>
> struct negate : public unary_function<_Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x) const
> { return -__x; }
> };
># 195 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _Tp>
> struct equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x == __y; }
> };
>
>
> template <class _Tp>
> struct not_equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x != __y; }
> };
>
>
> template <class _Tp>
> struct greater : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x > __y; }
> };
>
>
> template <class _Tp>
> struct less : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x < __y; }
> };
>
>
> template <class _Tp>
> struct greater_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x >= __y; }
> };
>
>
> template <class _Tp>
> struct less_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x <= __y; }
> };
># 256 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _Tp>
> struct logical_and : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x && __y; }
> };
>
>
> template <class _Tp>
> struct logical_or : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x || __y; }
> };
>
>
> template <class _Tp>
> struct logical_not : public unary_function<_Tp, bool>
> {
> bool
> operator()(const _Tp& __x) const
> { return !__x; }
> };
># 311 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _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 <class _Predicate>
> inline unary_negate<_Predicate>
> not1(const _Predicate& __pred)
> { return unary_negate<_Predicate>(__pred); }
>
>
> template <class _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 <class _Predicate>
> inline binary_negate<_Predicate>
> not2(const _Predicate& __pred)
> { return binary_negate<_Predicate>(__pred); }
># 391 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _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 <class _Operation, class _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 <class _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 <class _Operation, class _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));
> }
># 480 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _Arg, class _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 <class _Arg, class _Result>
> inline pointer_to_unary_function<_Arg, _Result>
> ptr_fun(_Result (*__x)(_Arg))
> { return pointer_to_unary_function<_Arg, _Result>(__x); }
>
>
> template <class _Arg1, class _Arg2, class _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 <class _Arg1, class _Arg2, class _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 <class _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 <class _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; }
> };
>
> template <class _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; }
> };
># 590 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_function.h" 3
> template <class _Ret, class _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 <class _Ret, class _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 <class _Ret, class _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 <class _Ret, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Tp>
> class mem_fun_t<void, _Tp> : public unary_function<_Tp*, void>
> {
> public:
> explicit
> mem_fun_t(void (_Tp::*__pf)())
> : _M_f(__pf) {}
>
> void
> operator()(_Tp* __p) const
> { (__p->*_M_f)(); }
> private:
> void (_Tp::*_M_f)();
> };
>
>
> template <class _Tp>
> class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*, void>
> {
> public:
> explicit
> const_mem_fun_t(void (_Tp::*__pf)() const)
> : _M_f(__pf) {}
>
> void
> operator()(const _Tp* __p) const
> { (__p->*_M_f)(); }
> private:
> void (_Tp::*_M_f)() const;
> };
>
>
> template <class _Tp>
> class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp, void>
> {
> public:
> explicit
> mem_fun_ref_t(void (_Tp::*__pf)())
> : _M_f(__pf) {}
>
> void
> operator()(_Tp& __r) const
> { (__r.*_M_f)(); }
> private:
> void (_Tp::*_M_f)();
> };
>
>
> template <class _Tp>
> class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp, void>
> {
> public:
> explicit
> const_mem_fun_ref_t(void (_Tp::*__pf)() const)
> : _M_f(__pf) {}
>
> void
> operator()(const _Tp& __r) const
> { (__r.*_M_f)(); }
> private:
> void (_Tp::*_M_f)() const;
> };
>
>
> template <class _Tp, class _Arg>
> class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*, _Arg, void>
> {
> public:
> explicit
> mem_fun1_t(void (_Tp::*__pf)(_Arg))
> : _M_f(__pf) {}
>
> void
> operator()(_Tp* __p, _Arg __x) const
> { (__p->*_M_f)(__x); }
> private:
> void (_Tp::*_M_f)(_Arg);
> };
>
>
> template <class _Tp, class _Arg>
> class const_mem_fun1_t<void, _Tp, _Arg>
> : public binary_function<const _Tp*, _Arg, void>
> {
> public:
> explicit
> const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) {}
>
> void
> operator()(const _Tp* __p, _Arg __x) const
> { (__p->*_M_f)(__x); }
> private:
> void (_Tp::*_M_f)(_Arg) const;
> };
>
>
> template <class _Tp, class _Arg>
> class mem_fun1_ref_t<void, _Tp, _Arg>
> : public binary_function<_Tp, _Arg, void>
> {
> public:
> explicit
> mem_fun1_ref_t(void (_Tp::*__pf)(_Arg))
> : _M_f(__pf) {}
>
> void
> operator()(_Tp& __r, _Arg __x) const
> { (__r.*_M_f)(__x); }
> private:
> void (_Tp::*_M_f)(_Arg);
> };
>
>
> template <class _Tp, class _Arg>
> class const_mem_fun1_ref_t<void, _Tp, _Arg>
> : public binary_function<_Tp, _Arg, void>
> {
> public:
> explicit
> const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) {}
>
> void
> operator()(const _Tp& __r, _Arg __x) const
> { (__r.*_M_f)(__x); }
> private:
> void (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template <class _Ret, class _Tp>
> inline mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)())
> { return mem_fun_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _Tp>
> inline const_mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _Tp>
> inline mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)())
> { return mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template <class _Ret, class _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 <class _Ret, class _Tp, class _Arg>
> inline mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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); }
>
>
>
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
>
>
>
>
>namespace std
>{
># 109 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_string
> {
>
> public:
> typedef _Traits traits_type;
> typedef typename _Traits::char_type value_type;
> typedef _Alloc allocator_type;
> typedef typename _Alloc::size_type size_type;
> typedef typename _Alloc::difference_type difference_type;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::const_reference const_reference;
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::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:
># 144 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 169 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()
> { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }
>
> 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; }
>
> _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(&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(&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;
> }
>
>
> size_type
> _M_limit(size_type __pos, size_type __off) const
> {
> const bool __testoff = __off < this->size() - __pos;
> return __testoff ? __off : this->size() - __pos;
> }
>
>
>
> 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)
> { traits_type::copy(__p, __k1, __k2 - __k1); }
>
> static void
> _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
> { traits_type::copy(__p, __k1, __k2 - __k1); }
>
> 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:
>
>
>
>
>
>
>
> inline
> basic_string();
>
>
>
>
> 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);
># 388 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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());
>
>
>
>
>
>
>
> 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)
> {
> this->assign(__str);
> return *this;
> }
>
>
>
>
>
> basic_string&
> operator=(const _CharT* __s)
> {
> this->assign(__s);
> return *this;
> }
># 449 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> operator=(_CharT __c)
> {
> this->assign(1, __c);
> return *this;
> }
>
>
>
>
>
>
> 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()); }
>
> 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; }
># 557 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> void
> resize(size_type __n, _CharT __c);
># 570 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> void
> resize(size_type __n) { this->resize(__n, _CharT()); }
>
>
>
>
>
> size_type
> capacity() const { return _M_rep()->_M_capacity; }
># 597 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 623 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> const_reference
> operator[] (size_type __pos) const
> {
> ;
> return _M_data()[__pos];
> }
># 640 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> reference
> operator[](size_type __pos)
> {
> ;
> _M_leak();
> return _M_data()[__pos];
> }
># 658 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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];
> }
># 677 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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];
> }
>
>
>
>
>
>
>
> 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) { return this->append(size_type(1), __c); }
>
>
>
>
>
>
> basic_string&
> append(const basic_string& __str);
># 731 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 763 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> append(size_type __n, _CharT __c)
> { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
># 775 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)
> { _M_replace_aux(this->size(), size_type(0), size_type(1), __c); }
>
>
>
>
>
>
> basic_string&
> assign(const basic_string& __str);
># 808 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)); }
># 824 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s, size_type __n);
># 836 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s)
> {
> ;
> return this->assign(__s, traits_type::length(__s));
> }
># 852 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> assign(size_type __n, _CharT __c)
> { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
># 864 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> assign(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
># 881 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> void
> insert(iterator __p, size_type __n, _CharT __c)
> { this->replace(__p, __p, __n, __c); }
># 896 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> template<class _InputIterator>
> void insert(iterator __p, _InputIterator __beg, _InputIterator __end)
> { this->replace(__p, __p, __beg, __end); }
># 911 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 933 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)); }
># 956 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s, size_type __n);
># 974 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s)
> {
> ;
> return this->insert(__pos, __s, traits_type::length(__s));
> }
># 997 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 1014 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 this->_M_ibegin() + __pos;
> }
># 1038 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> erase(size_type __pos = 0, size_type __n = npos)
> { return _M_replace_safe(_M_check(__pos, "basic_string::erase"),
> _M_limit(__pos, __n), __null, size_type(0)); }
># 1051 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> iterator
> erase(iterator __position)
> {
> ;
>
> const size_type __pos = __position - _M_ibegin();
> _M_replace_safe(__pos, size_type(1), __null, size_type(0));
> _M_rep()->_M_set_leaked();
> return _M_ibegin() + __pos;
> }
># 1071 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> iterator
> erase(iterator __first, iterator __last)
> {
> ;
>
> const size_type __pos = __first - _M_ibegin();
> _M_replace_safe(__pos, __last - __first, __null, size_type(0));
> _M_rep()->_M_set_leaked();
> return _M_ibegin() + __pos;
> }
># 1098 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1120 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)); }
># 1144 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2);
># 1163 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1186 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 1204 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1222 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
> }
># 1243 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1264 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
> }
># 1286 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> replace(iterator __i1, iterator __i2,
> _InputIterator __k1, _InputIterator __k2)
> {
> ;
>
> ;
> typedef typename _Is_integer<_InputIterator>::_Integral _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);
> }
>
> 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)
> {
> if (this->max_size() - (this->size() - __n1) < __n2)
> __throw_length_error(("basic_string::_M_replace_aux"));
> _M_mutate(__pos1, __n1, __n2);
> if (__n2 == 1)
> _M_data()[__pos1] = __c;
> else if (__n2)
> traits_type::assign(_M_data() + __pos1, __n2, __c);
> return *this;
> }
>
> basic_string&
> _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> _M_mutate(__pos1, __n1, __n2);
> if (__n2 == 1)
> _M_data()[__pos1] = *__s;
> else if (__n2)
> traits_type::copy(_M_data() + __pos1, __s, __n2);
> return *this;
> }
>
>
>
> 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 _InIterator>
> static _CharT*
> _S_construct_aux(_InIterator __beg, _InIterator __end,
> const _Alloc& __a, __true_type)
> { return _S_construct(static_cast<size_type>(__beg),
> static_cast<value_type>(__end), __a); }
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
> {
> typedef typename _Is_integer<_InIterator>::_Integral _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:
># 1435 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
># 1445 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> void
> swap(basic_string& __s);
># 1455 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 1484 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos, size_type __n) const;
># 1497 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1511 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1528 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find(_CharT __c, size_type __pos = 0) const;
># 1541 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1556 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos, size_type __n) const;
># 1569 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1586 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> rfind(_CharT __c, size_type __pos = npos) const;
># 1599 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1614 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1627 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1646 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_first_of(_CharT __c, size_type __pos = 0) const
> { return this->find(__c, __pos); }
># 1660 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1675 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1688 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1707 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_last_of(_CharT __c, size_type __pos = npos) const
> { return this->rfind(__c, __pos); }
># 1721 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1736 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 1750 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1767 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const;
># 1780 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1796 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 1809 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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));
> }
># 1826 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const;
># 1841 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 1859 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 = __size - __osize;
> return __r;
> }
># 1889 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n, const basic_string& __str) const;
># 1913 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> int
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const;
># 1931 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> int
> compare(const _CharT* __s) const;
># 1954 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s) const;
># 1979 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const;
> };
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>::
> basic_string()
>
> : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
># 2000 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 2071 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 _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; }
># 2108 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 __rhs.compare(__lhs) != 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; }
>
>
>
>
>
>
>
> 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; }
># 2145 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 2182 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 2219 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 2256 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 2293 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 2310 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
># 2324 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os,
> const basic_string<_CharT, _Traits, _Alloc>& __str);
># 2342 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
># 2359 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
>}
># 54 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/algorithm" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/algorithm" 3
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/algorithm" 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 1 3
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 3
>namespace std
>{
>
>
>
> template<typename _RandomAccessIterator, typename _Distance>
> bool
> __is_heap(_RandomAccessIterator __first, _Distance __n)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__first[__parent] < __first[__child])
> return false;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return true;
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _StrictWeakOrdering>
> bool
> __is_heap(_RandomAccessIterator __first, _StrictWeakOrdering __comp,
> _Distance __n)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__comp(__first[__parent], __first[__child]))
> return false;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return true;
> }
>
> template<typename _RandomAccessIterator>
> bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::__is_heap(__first, std::distance(__first, __last)); }
>
> template<typename _RandomAccessIterator, typename _StrictWeakOrdering>
> bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _StrictWeakOrdering __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;
> }
># 139 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
>
> 
>
> 
> ;
>
>
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), _ValueType(*(__last - 1)));
> }
>
> 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;
> }
># 187 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
>
> 
>
> ;
> ;
>
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), _ValueType(*(__last - 1)), __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 = 2 * __holeIndex + 2;
> while (__secondChild < __len)
> {
> if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
> __secondChild--;
> *(__first + __holeIndex) = *(__first + __secondChild);
> __holeIndex = __secondChild;
> __secondChild = 2 * (__secondChild + 1);
> }
> if (__secondChild == __len)
> {
> *(__first + __holeIndex) = *(__first + (__secondChild - 1));
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex, __value);
> }
>
> template<typename _RandomAccessIterator, typename _Tp>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result, _Tp __value)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> *__result = *__first;
> std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
> __value);
> }
># 251 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> std::__pop_heap(__first, __last - 1, __last - 1,
> _ValueType(*(__last - 1)));
> }
>
> 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 = 2 * __holeIndex + 2;
> while (__secondChild < __len)
> {
> if (__comp(*(__first + __secondChild),
> *(__first + (__secondChild - 1))))
> __secondChild--;
> *(__first + __holeIndex) = *(__first + __secondChild);
> __holeIndex = __secondChild;
> __secondChild = 2 * (__secondChild + 1);
> }
> if (__secondChild == __len)
> {
> *(__first + __holeIndex) = *(__first + (__secondChild - 1));
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result, _Tp __value, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> *__result = *__first;
> std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
> __value, __comp);
> }
># 317 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> pop_heap(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> std::__pop_heap(__first, __last - 1, __last - 1,
> _ValueType(*(__last - 1)), __comp);
> }
># 342 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)
> {
> std::__adjust_heap(__first, __parent, __len,
> _ValueType(*(__first + __parent)));
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 382 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline 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)
> {
> std::__adjust_heap(__first, __parent, __len,
> _ValueType(*(__first + __parent)), __comp);
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 420 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
>
>
> while (__last - __first > 1)
> std::pop_heap(__first, __last--);
> }
># 446 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> while (__last - __first > 1)
> std::pop_heap(__first, __last--, __comp);
> }
>
>}
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_tempbuf.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_tempbuf.h" 3
>namespace std
>{
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> class _Temporary_buffer
> {
>
> 
>
> public:
> typedef _Tp value_type;
> typedef value_type* pointer;
> typedef pointer iterator;
> typedef ptrdiff_t size_type;
>
> protected:
> size_type _M_original_len;
> size_type _M_len;
> pointer _M_buffer;
>
> void
> _M_initialize_buffer(const _Tp&, __true_type) { }
>
> void
> _M_initialize_buffer(const _Tp& val, __false_type)
> { std::uninitialized_fill_n(_M_buffer, _M_len, val); }
>
> public:
>
> size_type
> size() const
> { return _M_len; }
>
>
> size_type
> requested_size() const
> { return _M_original_len; }
>
>
> iterator
> begin()
> { return _M_buffer; }
>
>
> iterator
> end()
> { return _M_buffer + _M_len; }
>
>
>
>
>
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
>
> ~_Temporary_buffer()
> {
> std::_Destroy(_M_buffer, _M_buffer + _M_len);
> std::return_temporary_buffer(_M_buffer);
> }
>
> private:
>
> _Temporary_buffer(const _Temporary_buffer&);
>
> void
> operator=(const _Temporary_buffer&);
> };
>
>
> template<typename _ForwardIterator, typename _Tp>
> _Temporary_buffer<_ForwardIterator, _Tp>::
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
> : _M_original_len(std::distance(__first, __last)),
> _M_len(0), _M_buffer(0)
> {
>
> typedef typename __type_traits<_Tp>::has_trivial_default_constructor
> _Trivial;
>
> try
> {
> pair<pointer, size_type> __p(get_temporary_buffer<
> value_type>(_M_original_len));
> _M_buffer = __p.first;
> _M_len = __p.second;
> if (_M_len > 0)
> _M_initialize_buffer(*__first, _Trivial());
> }
> catch(...)
> {
> std::return_temporary_buffer(_M_buffer);
> _M_buffer = 0;
> _M_len = 0;
> throw;
> }
> }
>}
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 2 3
>
>
>
>
>namespace std
>{
># 84 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _Tp>
> inline const _Tp&
> __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
> {
>
> 
> if (__a < __b)
> if (__b < __c)
> return __b;
> else if (__a < __c)
> return __c;
> else
> return __a;
> else if (__a < __c)
> return __a;
> else if (__b < __c)
> return __c;
> else
> return __b;
> }
># 118 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
> {
>
> 
> if (__comp(__a, __b))
> if (__comp(__b, __c))
> return __b;
> else if (__comp(__a, __c))
> return __c;
> else
> return __a;
> else if (__comp(__a, __c))
> return __a;
> else if (__comp(__b, __c))
> return __c;
> else
> return __b;
> }
># 150 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Function>
> _Function
> for_each(_InputIterator __first, _InputIterator __last, _Function __f)
> {
>
> 
> ;
> for ( ; __first != __last; ++__first)
> __f(*__first);
> return __f;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val, input_iterator_tag)
> {
> while (__first != __last && !(*__first == __val))
> ++__first;
> return __first;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && !__pred(*__first))
> ++__first;
> return __first;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> find(_RandomAccessIterator __first, _RandomAccessIterator __last,
> const _Tp& __val, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for ( ; __trip_count > 0 ; --__trip_count)
> {
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (*__first == __val)
> return __first;
> ++__first;
> case 2:
> if (*__first == __val)
> return __first;
> ++__first;
> case 1:
> if (*__first == __val)
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _RandomAccessIterator
> find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Predicate __pred, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for ( ; __trip_count > 0 ; --__trip_count)
> {
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
>
> if (__pred(*__first))
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 2:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 1:
> if (__pred(*__first))
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
># 304 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
> return std::find(__first, __last, __val,
> std::__iterator_category(__first));
> }
># 326 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::find_if(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 348 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (*__first == *__next)
> return __first;
> __first = __next;
> }
> return __last;
> }
># 379 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (__binary_pred(*__first, *__next))
> return __first;
> __first = __next;
> }
> return __last;
> }
># 410 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> typename iterator_traits<_InputIterator>::difference_type
> count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
> {
>
> 
> 
>
> 
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for ( ; __first != __last; ++__first)
> if (*__first == __value)
> ++__n;
> return __n;
> }
># 435 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> typename iterator_traits<_InputIterator>::difference_type
> count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> {
>
> 
> 
>
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for ( ; __first != __last; ++__first)
> if (__pred(*__first))
> ++__n;
> return __n;
> }
># 474 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __tmp(__first2);
> ++__tmp;
> if (__tmp == __last2)
> return std::find(__first1, __last1, *__first2);
>
>
> _ForwardIterator2 __p1, __p;
> __p1 = __first2; ++__p1;
> _ForwardIterator1 __current = __first1;
>
> while (__first1 != __last1)
> {
> __first1 = std::find(__first1, __last1, *__first2);
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (*__current == *__p)
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 545 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __predicate)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __tmp(__first2);
> ++__tmp;
> if (__tmp == __last2)
> {
> while (__first1 != __last1 && !__predicate(*__first1, *__first2))
> ++__first1;
> return __first1;
> }
>
>
> _ForwardIterator2 __p1, __p;
> __p1 = __first2; ++__p1;
> _ForwardIterator1 __current = __first1;
>
> while (__first1 != __last1)
> {
> while (__first1 != __last1)
> {
> if (__predicate(*__first1, *__first2))
> break;
> ++__first1;
> }
> while (__first1 != __last1 && !__predicate(*__first1, *__first2))
> ++__first1;
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (__predicate(*__current, *__p))
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 623 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val)
> {
>
> 
> 
>
> 
> ;
>
> if (__count <= 0)
> return __first;
> else
> {
> __first = std::find(__first, __last, __val);
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && *__i == __val)
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> else
> __first = std::find(__i, __last, __val);
> }
> return __last;
> }
> }
># 675 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> else
> {
> while (__first != __last)
> {
> if (__binary_pred(*__first, __val))
> break;
> ++__first;
> }
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && __binary_pred(*__i, __val))
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> else
> {
> while (__i != __last)
> {
> if (__binary_pred(*__i, __val))
> break;
> ++__i;
> }
> __first = __i;
> }
> }
> return __last;
> }
> }
># 737 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.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;
> }
># 775 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _UnaryOperation>
> _OutputIterator
> transform(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _UnaryOperation __unary_op)
> {
>
> 
> 
>
>
> ;
>
> for ( ; __first != __last; ++__first, ++__result)
> *__result = __unary_op(*__first);
> return __result;
> }
># 810 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _BinaryOperation>
> _OutputIterator
> transform(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _OutputIterator __result,
> _BinaryOperation __binary_op)
> {
>
> 
> 
> 
>
>
> ;
>
> for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
> *__result = __binary_op(*__first1, *__first2);
> return __result;
> }
># 842 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> replace(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (*__first == __old_value)
> *__first = __new_value;
> }
># 873 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate, typename _Tp>
> void
> replace_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (__pred(*__first))
> *__first = __new_value;
> }
># 906 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> replace_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first, ++__result)
> *__result = *__first == __old_value ? __new_value : *__first;
> return __result;
> }
># 939 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate, typename _Tp>
> _OutputIterator
> replace_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first, ++__result)
> *__result = __pred(*__first) ? __new_value : *__first;
> return __result;
> }
># 970 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Generator>
> void
> generate(_ForwardIterator __first, _ForwardIterator __last,
> _Generator __gen)
> {
>
> 
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> *__first = __gen();
> }
># 996 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _OutputIterator, typename _Size, typename _Generator>
> _OutputIterator
> generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
> {
>
> 
>
>
>
> for ( ; __n > 0; --__n, ++__first)
> *__first = __gen();
> return __first;
> }
># 1023 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> remove_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, const _Tp& __value)
> {
>
> 
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (!(*__first == __value))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 1059 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> remove_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for ( ; __first != __last; ++__first)
> if (!__pred(*__first))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 1098 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> remove(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find(__first, __last, __value);
> _ForwardIterator __i = __first;
> return __first == __last ? __first
> : std::remove_copy(++__i, __last,
> __first, __value);
> }
># 1133 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> remove_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find_if(__first, __last, __pred);
> _ForwardIterator __i = __first;
> return __first == __last ? __first
> : std::remove_copy_if(++__i, __last,
> __first, __pred);
> }
># 1159 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> output_iterator_tag)
> {
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!(__value == *__first))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
># 1184 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> forward_iterator_tag)
> {
>
> *__result = *__first;
> while (++__first != __last)
> if (!(*__result == *__first))
> *++__result = *__first;
> return ++__result;
> }
># 1206 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _BinaryPredicate __binary_pred,
> output_iterator_tag)
> {
>
> 
>
>
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!__binary_pred(__value, *__first))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
># 1238 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> _BinaryPredicate __binary_pred,
> forward_iterator_tag)
> {
>
> 
>
>
>
> *__result = *__first;
> while (++__first != __last)
> if (!__binary_pred(*__result, *__first)) *++__result = *__first;
> return ++__result;
> }
># 1270 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> 
>
> ;
>
> typedef typename iterator_traits<_OutputIterator>::iterator_category
> _IterType;
>
> if (__first == __last) return __result;
> return std::__unique_copy(__first, __last, __result, _IterType());
> }
># 1305 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> typedef typename iterator_traits<_OutputIterator>::iterator_category
> _IterType;
>
> if (__first == __last) return __result;
> return std::__unique_copy(__first, __last, __result,
> __binary_pred, _IterType());
> }
># 1339 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
>
> 
>
> ;
>
>
> __first = std::adjacent_find(__first, __last);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!(*__dest == *__first))
> *++__dest = *__first;
> return ++__dest;
> }
># 1378 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
>
> 
>
>
> ;
>
>
> __first = std::adjacent_find(__first, __last, __binary_pred);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!__binary_pred(*__dest, *__first))
> *++__dest = *__first;
> return ++__dest;
> }
># 1412 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> void
> __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
> while (true)
> if (__first == __last || __first == --__last)
> return;
> else
> std::iter_swap(__first++, __last);
> }
># 1431 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> void
> __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
> while (__first < __last)
> std::iter_swap(__first++, --__last);
> }
># 1451 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline void
> reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
> {
>
> 
>
> ;
> std::__reverse(__first, __last, std::__iterator_category(__first));
> }
># 1477 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _OutputIterator>
> _OutputIterator
> reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _OutputIterator __result)
> {
>
> 
>
> 
>
> ;
>
> while (__first != __last)
> {
> --__last;
> *__result = *__last;
> ++__result;
> }
> return __result;
> }
># 1505 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _EuclideanRingElement>
> _EuclideanRingElement
> __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
> {
> while (__n != 0)
> {
> _EuclideanRingElement __t = __m % __n;
> __m = __n;
> __n = __t;
> }
> return __m;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator>
> void
> __rotate(_ForwardIterator __first,
> _ForwardIterator __middle,
> _ForwardIterator __last,
> forward_iterator_tag)
> {
> if ((__first == __middle) || (__last == __middle))
> return;
>
> _ForwardIterator __first2 = __middle;
> do
> {
> swap(*__first++, *__first2++);
> if (__first == __middle)
> __middle = __first2;
> }
> while (__first2 != __last);
>
> __first2 = __middle;
>
> while (__first2 != __last)
> {
> swap(*__first++, *__first2++);
> if (__first == __middle)
> __middle = __first2;
> else if (__first2 == __last)
> __first2 = __middle;
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator>
> void
> __rotate(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
>
> 
>
>
> if ((__first == __middle) || (__last == __middle))
> return;
>
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
>
> while (__first != __middle && __middle != __last)
> swap(*__first++, *--__last);
>
> if (__first == __middle)
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
> else
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __rotate(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
>
> if ((__first == __middle) || (__last == __middle))
> return;
>
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> const _Distance __n = __last - __first;
> const _Distance __k = __middle - __first;
> const _Distance __l = __n - __k;
>
> if (__k == __l)
> {
> std::swap_ranges(__first, __middle, __middle);
> return;
> }
>
> const _Distance __d = __gcd(__n, __k);
>
> for (_Distance __i = 0; __i < __d; __i++)
> {
> const _ValueType __tmp = *__first;
> _RandomAccessIterator __p = __first;
>
> if (__k < __l)
> {
> for (_Distance __j = 0; __j < __l / __d; __j++)
> {
> if (__p > __first + __l)
> {
> *__p = *(__p - __l);
> __p -= __l;
> }
>
> *__p = *(__p + __k);
> __p += __k;
> }
> }
> else
> {
> for (_Distance __j = 0; __j < __k / __d - 1; __j ++)
> {
> if (__p < __last - __k)
> {
> *__p = *(__p + __k);
> __p += __k;
> }
> *__p = * (__p - __l);
> __p -= __l;
> }
> }
>
> *__p = __tmp;
> ++__first;
> }
> }
># 1677 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline void
> rotate(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last)
> {
>
> 
>
> ;
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::iterator_category
> _IterType;
> std::__rotate(__first, __middle, __last, _IterType());
> }
># 1710 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _OutputIterator>
> _OutputIterator
> rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last, _OutputIterator __result)
> {
>
> 
> 
>
> ;
> ;
>
> return std::copy(__first, __middle, copy(__middle, __last, __result));
> }
># 1735 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> ;
>
> if (__first != __last)
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
> }
># 1762 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
> void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomNumberGenerator& __rand)
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __rand((__i - __first) + 1));
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> __partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred,
> forward_iterator_tag)
> {
> if (__first == __last)
> return __first;
>
> while (__pred(*__first))
> if (++__first == __last)
> return __first;
>
> _ForwardIterator __next = __first;
>
> while (++__next != __last)
> if (__pred(*__next))
> {
> swap(*__first, *__next);
> ++__first;
> }
>
> return __first;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Predicate>
> _BidirectionalIterator
> __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _Predicate __pred,
> bidirectional_iterator_tag)
> {
> while (true)
> {
> while (true)
> if (__first == __last)
> return __first;
> else if (__pred(*__first))
> ++__first;
> else
> break;
> --__last;
> while (true)
> if (__first == __last)
> return __first;
> else if (!__pred(*__last))
> --__last;
> else
> break;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
># 1856 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__partition(__first, __last, __pred,
> std::__iterator_category(__first));
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Predicate, typename _Distance>
> _ForwardIterator
> __inplace_stable_partition(_ForwardIterator __first,
> _ForwardIterator __last,
> _Predicate __pred, _Distance __len)
> {
> if (__len == 1)
> return __pred(*__first) ? __last : __first;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __begin = std::__inplace_stable_partition(__first,
> __middle,
> __pred,
> __len / 2);
> _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
> __pred,
> __len
> - __len / 2);
> std::rotate(__begin, __middle, __end);
> std::advance(__begin, std::distance(__middle, __end));
> return __begin;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
> typename _Distance>
> _ForwardIterator
> __stable_partition_adaptive(_ForwardIterator __first,
> _ForwardIterator __last,
> _Predicate __pred, _Distance __len,
> _Pointer __buffer,
> _Distance __buffer_size)
> {
> if (__len <= __buffer_size)
> {
> _ForwardIterator __result1 = __first;
> _Pointer __result2 = __buffer;
> for ( ; __first != __last ; ++__first)
> if (__pred(*__first))
> {
> *__result1 = *__first;
> ++__result1;
> }
> else
> {
> *__result2 = *__first;
> ++__result2;
> }
> std::copy(__buffer, __result2, __result1);
> return __result1;
> }
> else
> {
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __begin =
> std::__stable_partition_adaptive(__first, __middle, __pred,
> __len / 2, __buffer,
> __buffer_size);
> _ForwardIterator __end =
> std::__stable_partition_adaptive(__middle, __last, __pred,
> __len - __len / 2,
> __buffer, __buffer_size);
> std::rotate(__begin, __middle, __end);
> std::advance(__begin, std::distance(__middle, __end));
> return __begin;
> }
> }
># 1967 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> stable_partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return __first;
> else
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.size() > 0)
> return
> std::__stable_partition_adaptive(__first, __last, __pred,
> _DistanceType(__buf.requested_size()),
> __buf.begin(), __buf.size());
> else
> return
> std::__inplace_stable_partition(__first, __last, __pred,
> _DistanceType(__buf.requested_size()));
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Tp __pivot)
> {
> while (true)
> {
> while (*__first < __pivot)
> ++__first;
> --__last;
> while (__pivot < *__last)
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Tp __pivot, _Compare __comp)
> {
> while (true)
> {
> while (__comp(*__first, __pivot))
> ++__first;
> --__last;
> while (__comp(__pivot, *__last))
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
>
> enum { _S_threshold = 16 };
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val)
> {
> _RandomAccessIterator __next = __last;
> --__next;
> while (__val < *__next)
> {
> *__last = *__next;
> __last = __next;
> --__next;
> }
> *__last = __val;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val,
> _Compare __comp)
> {
> _RandomAccessIterator __next = __last;
> --__next;
> while (__comp(__val, *__next))
> {
> *__last = *__next;
> __last = __next;
> --__next;
> }
> *__last = __val;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__first == __last)
> return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = *__i;
> if (__val < *__first)
> {
> std::copy_backward(__first, __i, __i + 1);
> *__first = __val;
> }
> else
> std::__unguarded_linear_insert(__i, __val);
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__first == __last) return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = *__i;
> if (__comp(__val, *__first))
> {
> std::copy_backward(__first, __i, __i + 1);
> *__first = __val;
> }
> else
> std::__unguarded_linear_insert(__i, __val, __comp);
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, _ValueType(*__i));
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, _ValueType(*__i), __comp);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first > _S_threshold)
> {
> std::__insertion_sort(__first, __first + _S_threshold);
> std::__unguarded_insertion_sort(__first + _S_threshold, __last);
> }
> else
> std::__insertion_sort(__first, __last);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first > _S_threshold)
> {
> std::__insertion_sort(__first, __first + _S_threshold, __comp);
> std::__unguarded_insertion_sort(__first + _S_threshold, __last,
> __comp);
> }
> else
> std::__insertion_sort(__first, __last, __comp);
> }
>
>
>
>
>
>
> template<typename _Size>
> inline _Size
> __lg(_Size __n)
> {
> _Size __k;
> for (__k = 0; __n != 1; __n >>= 1)
> ++__k;
> return __k;
> }
># 2256 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> std::make_heap(__first, __middle);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (*__i < *__first)
> std::__pop_heap(__first, __middle, __i, _ValueType(*__i));
> std::sort_heap(__first, __middle);
> }
># 2297 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> std::make_heap(__first, __middle, __comp);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (__comp(*__i, *__first))
> std::__pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
> std::sort_heap(__first, __middle, __comp);
> }
># 2339 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator>
> _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
> 
> ;
> ;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while(__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
> std::make_heap(__result_first, __result_real_last);
> while (__first != __last)
> {
> if (*__first < *__result_first)
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first));
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last);
> return __result_real_last;
> }
># 2403 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
> _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _OutputValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while(__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
> std::make_heap(__result_first, __result_real_last, __comp);
> while (__first != __last)
> {
> if (__comp(*__first, *__result_first))
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first),
> __comp);
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last, __comp);
> return __result_real_last;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Size>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > _S_threshold)
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last
> - 1))));
> std::__introsort_loop(__cut, __last, __depth_limit);
> __last = __cut;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > _S_threshold)
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last, __comp);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last - 1),
> __comp)),
> __comp);
> std::__introsort_loop(__cut, __last, __depth_limit, __comp);
> __last = __cut;
> }
> }
># 2538 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last, __lg(__last - __first) * 2);
> std::__final_insertion_sort(__first, __last);
> }
> }
># 2572 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last, __lg(__last - __first) * 2,
> __comp);
> std::__final_insertion_sort(__first, __last, __comp);
> }
> }
># 2605 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>
>
>
>
> 
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 2660 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 2707 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>
> 
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__val < *__middle)
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
># 2759 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (*__middle < *__first)
> std::iter_swap(__first, __middle);
> return;
> }
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut);
> __len11 = std::distance(__first, __first_cut);
> }
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22);
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Compare>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Compare __comp)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (__comp(*__middle, *__first))
> std::iter_swap(__first, __middle);
> return;
> }
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22, __comp);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22, __comp);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle);
> std::__inplace_stable_sort(__middle, __last);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle);
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last, __comp);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle, __comp);
> std::__inplace_stable_sort(__middle, __last, __comp);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle,
> __comp);
> }
># 2957 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 3015 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result,
> _Distance __step_size)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::merge(__first, __first + __step_size,
> __first + __step_size, __first + __two_step,
> __result);
> __first += __two_step;
> }
>
> __step_size = std::min(_Distance(__last - __first), __step_size);
> std::merge(__first, __first + __step_size, __first + __step_size, __last,
> __result);
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance, typename _Compare>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result, _Distance __step_size,
> _Compare __comp)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::merge(__first, __first + __step_size,
> __first + __step_size, __first + __two_step,
> __result,
> __comp);
> __first += __two_step;
> }
> __step_size = std::min(_Distance(__last - __first), __step_size);
>
> std::merge(__first, __first + __step_size,
> __first + __step_size, __last,
> __result,
> __comp);
> }
>
> enum { _S_chunk_size = 7 };
>
> template<typename _RandomAccessIterator, typename _Distance>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Compare>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size, _Compare __comp)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size, __comp);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer, __step_size);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
> __step_size *= 2;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer,
> __step_size, __comp);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first,
> __step_size, __comp);
> __step_size *= 2;
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3>
> _BidirectionalIterator3
> __merge_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result)
> {
> if (__first1 == __last1)
> return std::copy_backward(__first2, __last2, __result);
> if (__first2 == __last2)
> return std::copy_backward(__first1, __last1, __result);
> --__last1;
> --__last2;
> while (true)
> {
> if (*__last2 < *__last1)
> {
> *--__result = *__last1;
> if (__first1 == __last1)
> return std::copy_backward(__first2, ++__last2, __result);
> --__last1;
> }
> else
> {
> *--__result = *__last2;
> if (__first2 == __last2)
> return std::copy_backward(__first1, ++__last1, __result);
> --__last2;
> }
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3, typename _Compare>
> _BidirectionalIterator3
> __merge_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result,
> _Compare __comp)
> {
> if (__first1 == __last1)
> return std::copy_backward(__first2, __last2, __result);
> if (__first2 == __last2)
> return std::copy_backward(__first1, __last1, __result);
> --__last1;
> --__last2;
> while (true)
> {
> if (__comp(*__last2, *__last1))
> {
> *--__result = *__last1;
> if (__first1 == __last1)
> return std::copy_backward(__first2, ++__last2, __result);
> --__last1;
> }
> else
> {
> *--__result = *__last2;
> if (__first2 == __last2)
> return std::copy_backward(__first1, ++__last1, __result);
> --__last2;
> }
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _Distance>
> _BidirectionalIterator1
> __rotate_adaptive(_BidirectionalIterator1 __first,
> _BidirectionalIterator1 __middle,
> _BidirectionalIterator1 __last,
> _Distance __len1, _Distance __len2,
> _BidirectionalIterator2 __buffer,
> _Distance __buffer_size)
> {
> _BidirectionalIterator2 __buffer_end;
> if (__len1 > __len2 && __len2 <= __buffer_size)
> {
> __buffer_end = std::copy(__middle, __last, __buffer);
> std::copy_backward(__first, __middle, __last);
> return std::copy(__buffer, __buffer_end, __first);
> }
> else if (__len1 <= __buffer_size)
> {
> __buffer_end = std::copy(__first, __middle, __buffer);
> std::copy(__middle, __last, __first);
> return std::copy_backward(__buffer, __buffer_end, __last);
> }
> else
> {
> std::rotate(__first, __middle, __last);
> std::advance(__first, std::distance(__middle, __last));
> return __first;
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
> std::merge(__buffer, __buffer_end, __middle, __last, __first);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
> std::__merge_backward(__first, __middle, __buffer,
> __buffer_end, __last);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last,
> *__first_cut);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle,
> *__second_cut);
> __len11 = std::distance(__first, __first_cut);
> }
> _BidirectionalIterator __new_middle =
> std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer, __buffer_size);
> }
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator, typename _Distance, typename _Pointer,
> typename _Compare>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
> std::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
> std::__merge_backward(__first, __middle, __buffer, __buffer_end,
> __last, __comp);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut = std::lower_bound(__middle, __last, *__first_cut,
> __comp);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut,
> __comp);
> __len11 = std::distance(__first, __first_cut);
> }
> _BidirectionalIterator __new_middle =
> std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size, __comp);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer,
> __buffer_size, __comp);
> }
> }
># 3435 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> _DistanceType __len1 = std::distance(__first, __middle);
> _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()));
> }
># 3489 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
>
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> const _DistanceType __len1 = std::distance(__first, __middle);
> const _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1,
> __len2, __comp);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()),
> __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle,
> __buffer, __buffer_size);
> std::__stable_sort_adaptive(__middle, __last,
> __buffer, __buffer_size);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer);
> std::__merge_sort_with_buffer(__middle, __last, __buffer);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance, typename _Compare>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle, __buffer,
> __buffer_size, __comp);
> std::__stable_sort_adaptive(__middle, __last, __buffer,
> __buffer_size, __comp);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
> std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size,
> __comp);
> }
># 3598 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType>
> buf(__first, __last);
> if (buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last);
> else
> std::__stable_sort_adaptive(__first, __last, buf.begin(),
> _DistanceType(buf.size()));
> }
># 3639 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
>
>
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
> if (buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last, __comp);
> else
> std::__stable_sort_adaptive(__first, __last, buf.begin(),
> _DistanceType(buf.size()), __comp);
> }
># 3680 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> void
> nth_element(_RandomAccessIterator __first,
> _RandomAccessIterator __nth,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> while (__last - __first > 3)
> {
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last
> - 1))));
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last);
> }
># 3731 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> nth_element(_RandomAccessIterator __first,
> _RandomAccessIterator __nth,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> while (__last - __first > 3)
> {
> _RandomAccessIterator __cut =
> std::__unguarded_partition(__first, __last,
> _ValueType(std::__median(*__first,
> *(__first
> + (__last
> - __first)
> / 2),
> *(__last - 1),
> __comp)), __comp);
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
># 3784 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
>
> 
> 
> 
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle, __left, __right;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__val < *__middle)
> __len = __half;
> else
> {
> __left = std::lower_bound(__first, __middle, __val);
> std::advance(__first, __len);
> __right = std::upper_bound(++__middle, __first, __val);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 3846 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val,
> _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
>
> 
> 
>
> 
>
> ;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle, __left, __right;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__comp(*__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> __left = std::lower_bound(__first, __middle, __val, __comp);
> std::advance(__first, __len);
> __right = std::upper_bound(++__middle, __first, __val, __comp);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 3904 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
>
> 
> 
>
> 
> ;
>
> _ForwardIterator __i = std::lower_bound(__first, __last, __val);
> return __i != __last && !(__val < *__i);
> }
># 3936 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
>
> 
> 
>
> 
>
> ;
>
> _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
> return __i != __last && !__comp(__val, *__i);
> }
># 3974 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
>
> 
> 
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
> return false;
> else if(*__first1 < *__first2)
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 4020 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
> return false;
> else if(__comp(*__first1, *__first2))
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 4066 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 4128 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 4189 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> ++__first1;
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 4243 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> ++__first1;
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 4297 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 4355 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 4409 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2, std::copy(__first1,
> __last1, __result));
> }
># 4470 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result,
> _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
> 
>
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(*__first2, *__first1))
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2, std::copy(__first1,
> __last1, __result));
> }
># 4523 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__result < *__first)
> __result = __first;
> return __result;
> }
># 4550 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last) return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(*__result, *__first)) __result = __first;
> return __result;
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__first < *__result)
> __result = __first;
> return __result;
> }
># 4602 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(*__first, *__result))
> __result = __first;
> return __result;
> }
># 4637 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__i < *__ii)
> {
> _BidirectionalIterator __j = __last;
> while (!(*__i < *--__j))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4693 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(*__i, *__ii))
> {
> _BidirectionalIterator __j = __last;
> while (!__comp(*__i, *--__j))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4748 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__ii < *__i)
> {
> _BidirectionalIterator __j = __last;
> while (!(*--__j < *__i))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4804 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(*__ii, *__i))
> {
> _BidirectionalIterator __j = __last;
> while (!__comp(*--__j, *__i))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 4863 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for ( ; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (*__first1 == *__iter)
> return __first1;
> return __last1;
> }
># 4899 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for ( ; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (__comp(*__first1, *__iter))
> return __first1;
> return __last1;
> }
># 4929 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2, __last2);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag,
> _BinaryPredicate __comp)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2, __last2, __comp);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
> _RevIterator2(__last2), __rlast2);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BinaryPredicate>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag,
> _BinaryPredicate __comp)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
> _RevIterator2(__last2), __rlast2,
> __comp);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
># 5079 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2));
> }
># 5124 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> __comp);
> }
>
>}
># 70 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/algorithm" 2 3
># 57 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.tcc" 1 3
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.tcc" 3
> 
># 45 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.tcc" 3
>
>namespace std
>{
> 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 _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);
> traits_type::copy(__r->_M_refdata(), __buf, __len);
> try
> {
> while (__beg != __end)
> {
> if (__len == __r->_M_capacity)
> {
>
> _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
> traits_type::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_length = __len;
> __r->_M_refdata()[__len] = _Rep::_S_terminal;
> 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 (__builtin_expect(__is_null_pointer(__beg) && __beg != __end, 0))
> __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_length = __dnew;
> __r->_M_refdata()[__dnew] = _Rep::_S_terminal;
> 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)
> traits_type::assign(__r->_M_refdata(), __n, __c);
>
> __r->_M_length = __n;
> __r->_M_refdata()[__n] = _Rep::_S_terminal;
> 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)
> { }
>
> 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)
> {
> ;
> if (__n > this->max_size())
> __throw_length_error(("basic_string::assign"));
> if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s))
> return _M_replace_safe(size_type(0), this->size(), __s, __n);
> else
> {
>
> const size_type __pos = __s - _M_data();
> if (__pos >= __n)
> traits_type::copy(_M_data(), __s, __n);
> else if (__pos)
> traits_type::move(_M_data(), __s, __n);
> _M_rep()->_M_set_sharable();
> _M_rep()->_M_length = __n;
> _M_data()[__n] = _Rep::_S_terminal;
> 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");
> if (this->max_size() - this->size() < __n)
> __throw_length_error(("basic_string::insert"));
> if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s))
> 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)
> traits_type::copy(__p, __s, __n);
> else if (__s >= __p)
> traits_type::copy(__p, __s + __n, __n);
> else
> {
> const size_type __nleft = __p - __s;
> traits_type::copy(__p, __s, __nleft);
> traits_type::copy(__p + __nleft, __p + __n, __n - __nleft);
> }
> return *this;
> }
> }
>
> 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);
> if (this->max_size() - (this->size() - __n1) < __n2)
> __throw_length_error(("basic_string::replace"));
> bool __left;
> if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s))
> return _M_replace_safe(__pos, __n1, __s, __n2);
> else if ((__left = __s + __n2 <= _M_data() + __pos)
> || _M_data() + __pos + __n1 <= __s)
> {
>
> const size_type __off = __s - _M_data();
> _M_mutate(__pos, __n1, __n2);
> if (__left)
> traits_type::copy(_M_data() + __pos,
> _M_data() + __off, __n2);
> else
> traits_type::copy(_M_data() + __pos,
> _M_data() + __off + __n2 - __n1, __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 ()
> {
>
> if (this == &_S_empty_rep())
> return;
>
> 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 > capacity() || _M_rep()->_M_is_shared())
> {
>
> const allocator_type __a = get_allocator();
> _Rep* __r = _Rep::_S_create(__new_size, capacity(), __a);
>
> if (__pos)
> traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
> if (__how_much)
> traits_type::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)
> {
>
> traits_type::move(_M_data() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
> }
> _M_rep()->_M_set_sharable();
> _M_rep()->_M_length = __new_size;
> _M_data()[__new_size] = _Rep::_S_terminal;
>
> }
>
> 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->max_size())
> __throw_length_error(("basic_string::reserve"));
>
> 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)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
>
>
> if (__capacity > _S_max_size)
> __throw_length_error(("basic_string::_S_create"));
># 501 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.tcc" 3
> const size_type __pagesize = 4096;
> const size_type __subpagesize = 128;
> const size_type __malloc_header_size = 4 * sizeof (void*);
># 513 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_string.tcc" 3
> const size_type __page_capacity = ((__pagesize - __malloc_header_size
> - sizeof(_Rep) - sizeof(_CharT))
> / sizeof(_CharT));
>
> if (__capacity > __old_capacity && __capacity < 2 * __old_capacity
> && __capacity > __page_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)
> {
> 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);
> }
> else if (__size > __subpagesize)
> {
> const size_type __extra = __subpagesize - __adj_size % __subpagesize;
> __capacity += __extra / sizeof(_CharT);
> __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();
> __p->_M_length = 0;
> 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)
> traits_type::copy(__r->_M_refdata(), _M_refdata(),
> this->_M_length);
>
> __r->_M_length = this->_M_length;
> __r->_M_refdata()[this->_M_length] = _Rep::_S_terminal;
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
> {
> if (__n > max_size())
> __throw_length_error(("basic_string::resize"));
> const size_type __size = this->size();
> 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;
> if (this->max_size() - (this->size() - __n1) < __s.size())
> __throw_length_error(("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>::
> append(const basic_string& __str)
> {
>
>
>
> const size_type __size = __str.size();
> const size_type __len = __size + this->size();
> if (__len > this->capacity())
> this->reserve(__len);
> return _M_replace_safe(this->size(), size_type(0), __str._M_data(),
> __str.size());
> }
>
> 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);
> const size_type __len = __n + this->size();
> if (__len > this->capacity())
> this->reserve(__len);
> return _M_replace_safe(this->size(), size_type(0), __str._M_data()
> + __pos, __n);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const _CharT* __s, size_type __n)
> {
> ;
> const size_type __len = __n + this->size();
> if (__len > this->capacity())
> this->reserve(__len);
> return _M_replace_safe(this->size(), size_type(0), __s, __n);
> }
>
> 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)
> traits_type::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();
> for (; __pos + __n <= __size; ++__pos)
> if (traits_type::compare(__data + __pos, __s, __n) == 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
> {
> const size_type __size = this->size();
> size_type __ret = npos;
> 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 = __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 = __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 = __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 = __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 = __n1 - __n2;
> return __r;
> }
>
>
>
>
>
> 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&);
>
>
>}
># 58 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/string" 2 3
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 2 3
>
>
>
>namespace std
>{
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 105 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
># 124 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> locale() throw();
># 133 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> locale(const locale& __other) throw();
># 143 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> explicit
> locale(const char* __s);
># 158 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> locale(const locale& __base, const char* __s, category __cat);
># 171 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> locale(const locale& __base, const locale& __add, category __cat);
># 183 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> template<typename _Facet>
> locale(const locale& __other, _Facet* __f);
>
>
> ~locale() throw();
># 197 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> const locale&
> operator=(const locale& __other) throw();
># 212 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> template<typename _Facet>
> locale
> combine(const locale& __other) const;
>
>
>
>
>
>
> string
> name() const;
># 231 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> bool
> operator==(const locale& __other) const throw ();
>
>
>
>
>
>
>
> inline bool
> operator!=(const locale& __other) const throw ()
> { return !(this->operator==(__other)); }
># 259 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 275 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> static locale
> global(const locale&);
>
>
>
>
> static const locale&
> classic();
>
> private:
>
> _Impl* _M_impl;
>
>
> static _Impl* _S_classic;
>
>
> static _Impl* _S_global;
>
>
>
>
>
> static const char* const* const _S_categories;
># 310 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_classes.h" 3
> static const size_t _S_categories_size = 6 + 6;
>
>
> static __gthread_once_t _S_once;
>
>
> explicit
> locale(_Impl*) throw();
>
> static void
> _S_initialize();
>
> static void
> _S_initialize_once();
>
> static category
> _S_normalize_category(category);
>
> void
> _M_coalesce(const locale& __base, const locale& __add, category __cat);
> };
># 343 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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:
># 374 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
>
> static void
> _S_destroy_c_locale(__c_locale& __cloc);
>
>
>
> static __c_locale
> _S_get_c_locale();
>
> static const char*
> _S_get_c_name();
>
> private:
> inline void
> _M_add_reference() const throw()
> { __gnu_cxx::__atomic_add(&_M_refcount, 1); }
>
> inline void
> _M_remove_reference() const throw()
> {
> if (__gnu_cxx::__exchange_and_add(&_M_refcount, -1) == 1)
> {
> try
> { delete this; }
> catch (...)
> { }
> }
> }
>
> facet(const facet&);
>
> facet&
> operator=(const facet&);
> };
># 434 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> };
>
>
>
> 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[];
>
> inline void
> _M_add_reference() throw()
> { __gnu_cxx::__atomic_add(&_M_refcount, 1); }
>
> inline void
> _M_remove_reference() throw()
> {
> if (__gnu_cxx::__exchange_and_add(&_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&);
>
> inline bool
> _M_check_same_name()
> {
> bool __ret = true;
> for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
> __ret = std::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>
> inline void
> _M_init_facet(_Facet* __facet)
> { _M_install_facet(&_Facet::id, __facet); }
>
> void
> _M_install_cache(const facet* __cache, size_t __index) throw()
> {
> __cache->_M_add_reference();
> _M_caches[__index] = __cache;
> }
> };
>
> template<typename _Facet>
> locale::locale(const locale& __other, _Facet* __f)
> {
> _M_impl = new _Impl(*__other._M_impl, 1);
>
> char* _M_tmp_names[_S_categories_size];
> size_t __i = 0;
> try
> {
> for (; __i < _S_categories_size; ++__i)
> {
> _M_tmp_names[__i] = new char[2];
> std::strcpy(_M_tmp_names[__i], "*");
> }
> _M_impl->_M_install_facet(&_Facet::id, __f);
> }
> catch(...)
> {
> _M_impl->_M_remove_reference();
> for (size_t __j = 0; __j < __i; ++__j)
> delete [] _M_tmp_names[__j];
> throw;
> }
>
> for (size_t __k = 0; __k < _S_categories_size; ++__k)
> {
> delete [] _M_impl->_M_names[__k];
> _M_impl->_M_names[__k] = _M_tmp_names[__k];
> }
> }
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 2 3
>
>namespace std
>{
>
>
>
>
> 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, _Ios_Fmtflags __b)
> { return __a = __a | __b; }
>
> inline _Ios_Fmtflags&
> operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a & __b; }
>
> inline _Ios_Fmtflags&
> operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a ^ __b; }
>
> inline _Ios_Fmtflags
> operator~(_Ios_Fmtflags __a)
> { return _Ios_Fmtflags(~static_cast<int>(__a)); }
>
>
> 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, _Ios_Openmode __b)
> { return __a = __a | __b; }
>
> inline _Ios_Openmode&
> operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a & __b; }
>
> inline _Ios_Openmode&
> operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a ^ __b; }
>
> inline _Ios_Openmode
> operator~(_Ios_Openmode __a)
> { return _Ios_Openmode(~static_cast<int>(__a)); }
>
>
> 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, _Ios_Iostate __b)
> { return __a = __a | __b; }
>
> inline _Ios_Iostate&
> operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a & __b; }
>
> inline _Ios_Iostate&
> operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a ^ __b; }
>
> inline _Ios_Iostate
> operator~(_Ios_Iostate __a)
> { return _Ios_Iostate(~static_cast<int>(__a)); }
>
> enum _Ios_Seekdir
> {
> _S_beg = 0,
> _S_cur = 1,
> _S_end = 2,
> _S_ios_seekdir_end = 1L << 16
> };
># 201 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> };
># 253 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> typedef _Ios_Fmtflags fmtflags;
>
>
> static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha);
>
>
> static const fmtflags dec = fmtflags(__ios_flags::_S_dec);
>
>
> static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed);
>
>
> static const fmtflags hex = fmtflags(__ios_flags::_S_hex);
>
>
>
>
> static const fmtflags internal = fmtflags(__ios_flags::_S_internal);
>
>
>
> static const fmtflags left = fmtflags(__ios_flags::_S_left);
>
>
> static const fmtflags oct = fmtflags(__ios_flags::_S_oct);
>
>
>
> static const fmtflags right = fmtflags(__ios_flags::_S_right);
>
>
> static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific);
>
>
>
> static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase);
>
>
>
> static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint);
>
>
> static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos);
>
>
> static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws);
>
>
> static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf);
>
>
>
> static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase);
>
>
> static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);
>
>
> static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield);
>
>
> static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield);
># 328 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> typedef _Ios_Iostate iostate;
>
>
>
> static const iostate badbit = iostate(__ios_flags::_S_badbit);
>
>
> static const iostate eofbit = iostate(__ios_flags::_S_eofbit);
>
>
>
>
> static const iostate failbit = iostate(__ios_flags::_S_failbit);
>
>
> static const iostate goodbit = iostate(0);
># 359 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> typedef _Ios_Openmode openmode;
>
>
> static const openmode app = openmode(__ios_flags::_S_app);
>
>
> static const openmode ate = openmode(__ios_flags::_S_ate);
>
>
>
>
>
> static const openmode binary = openmode(__ios_flags::_S_bin);
>
>
> static const openmode in = openmode(__ios_flags::_S_in);
>
>
> static const openmode out = openmode(__ios_flags::_S_out);
>
>
> static const openmode trunc = openmode(__ios_flags::_S_trunc);
># 392 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> typedef _Ios_Seekdir seekdir;
>
>
> static const seekdir beg = seekdir(0);
>
>
> static const seekdir cur = seekdir(1);
>
>
> static const seekdir end = seekdir(2);
># 420 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> enum event
> {
> erase_event,
> imbue_event,
> copyfmt_event
> };
># 437 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> typedef void (*event_callback) (event, ios_base&, int);
># 449 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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(&_M_refcount, 1); }
>
>
> int
> _M_remove_reference()
> { return __gnu_cxx::__exchange_and_add(&_M_refcount, -1); }
> };
>
> _Callback_list* _M_callbacks;
>
> void
> _M_call_callbacks(event __ev) throw();
>
> void
> _M_dispose_callbacks(void);
>
>
> struct _Words
> {
> void* _M_pword;
> long _M_iword;
> _Words() : _M_pword(0), _M_iword(0) { }
> };
>
>
> _Words _M_word_zero;
>
>
>
> static const int _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();
>
> public:
>
>
>
>
>
> class Init
> {
> friend class ios_base;
> public:
> Init();
> ~Init();
>
> private:
> static _Atomic_word _S_refcount;
> static bool _S_synced_with_stdio;
> };
>
>
>
>
>
>
> inline fmtflags
> flags() const { return _M_flags; }
># 559 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline fmtflags
> flags(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags = __fmtfl;
> return __old;
> }
># 575 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline fmtflags
> setf(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags |= __fmtfl;
> return __old;
> }
># 592 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline fmtflags
> setf(fmtflags __fmtfl, fmtflags __mask)
> {
> fmtflags __old = _M_flags;
> _M_flags &= ~__mask;
> _M_flags |= (__fmtfl & __mask);
> return __old;
> }
>
>
>
>
>
>
>
> inline void
> unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
># 619 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline streamsize
> precision() const { return _M_precision; }
>
>
>
>
>
>
> inline streamsize
> precision(streamsize __prec)
> {
> streamsize __old = _M_precision;
> _M_precision = __prec;
> return __old;
> }
>
>
>
>
>
>
>
> inline streamsize
> width() const { return _M_width; }
>
>
>
>
>
>
> inline streamsize
> width(streamsize __wide)
> {
> streamsize __old = _M_width;
> _M_width = __wide;
> return __old;
> }
># 668 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> static bool
> sync_with_stdio(bool __sync = true);
># 680 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> locale
> imbue(const locale& __loc);
># 691 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline locale
> getloc() const { return _M_ios_locale; }
># 701 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline const locale&
> _M_getloc() const { return _M_ios_locale; }
># 719 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> static int
> xalloc() throw();
># 735 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline long&
> iword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, true);
> return __word._M_iword;
> }
># 756 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> inline void*&
> pword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, false);
> return __word._M_pword;
> }
># 773 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ios_base.h" 3
> virtual ~ios_base();
>
> protected:
> ios_base();
>
>
>
> 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;
> }
>}
># 50 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
>
>
>
>
>
>
>namespace std
>{
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout);
># 122 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 145 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> 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<>(__streambuf_type* __sbin,
> __streambuf_type* __sbout);
>
> protected:
># 169 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> 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()
> { }
># 197 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> locale
> pubimbue(const locale &__loc)
> {
> locale __tmp(this->getloc());
> this->imbue(__loc);
> _M_buf_locale = __loc;
> return __tmp;
> }
># 214 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> locale
> getloc() const
> { return _M_buf_locale; }
># 227 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> __streambuf_type*
> pubsetbuf(char_type* __s, streamsize __n)
> { return this->setbuf(__s, __n); }
>
> pos_type
> pubseekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekoff(__off, __way, __mode); }
>
> pos_type
> pubseekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekpos(__sp, __mode); }
>
> int
> pubsync() { return this->sync(); }
># 254 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> streamsize
> in_avail()
> {
> const streamsize __ret = this->egptr() - this->gptr();
> return __ret ? __ret : this->showmanyc();
> }
># 268 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 286 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 308 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 327 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> streamsize
> sgetn(char_type* __s, streamsize __n)
> { return this->xsgetn(__s, __n); }
># 341 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 366 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 393 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 419 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> streamsize
> sputn(const char_type* __s, streamsize __n)
> { return this->xsputn(__s, __n); }
>
> protected:
># 433 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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())
> { }
># 451 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 467 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> void
> gbump(int __n) { _M_in_cur += __n; }
># 478 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 498 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 514 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> void
> pbump(int __n) { _M_out_cur += __n; }
># 524 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> void
> setp(char_type* __pbeg, char_type* __pend)
> {
> _M_out_beg = _M_out_cur = __pbeg;
> _M_out_end = __pend;
> }
># 545 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual void
> imbue(const locale&)
> { }
># 560 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual basic_streambuf<char_type,_Traits>*
> setbuf(char_type*, streamsize)
> { return this; }
># 571 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)); }
># 583 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual pos_type
> seekpos(pos_type,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 596 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual int
> sync() { return 0; }
># 618 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual streamsize
> showmanyc() { return 0; }
># 634 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual streamsize
> xsgetn(char_type* __s, streamsize __n);
># 656 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual int_type
> underflow()
> { return traits_type::eof(); }
># 669 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 693 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual int_type
> pbackfail(int_type = traits_type::eof())
> { return traits_type::eof(); }
># 711 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual streamsize
> xsputn(const char_type* __s, streamsize __n);
># 736 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> virtual int_type
> overflow(int_type = traits_type::eof())
> { return traits_type::eof(); }
># 765 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 3
> private:
>
>
> basic_streambuf(const __streambuf_type& __sb)
> : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
> _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
> _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
> _M_buf_locale(__sb._M_buf_locale)
> { }
>
> __streambuf_type&
> operator=(const __streambuf_type&) { return *this; };
> };
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/streambuf.tcc" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/streambuf.tcc" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/streambuf.tcc" 3
>
>namespace std
>{
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsgetn(char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const size_t __buf_len = this->egptr() - this->gptr();
> if (__buf_len)
> {
> const size_t __remaining = __n - __ret;
> const size_t __len = std::min(__buf_len, __remaining);
> traits_type::copy(__s, this->gptr(), __len);
> __ret += __len;
> __s += __len;
> this->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 size_t __buf_len = this->epptr() - this->pptr();
> if (__buf_len)
> {
> const size_t __remaining = __n - __ret;
> const size_t __len = std::min(__buf_len, __remaining);
> traits_type::copy(this->pptr(), __s, __len);
> __ret += __len;
> __s += __len;
> this->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(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout)
> {
> streamsize __ret = 0;
> typename _Traits::int_type __c = __sbin->sgetc();
> while (!_Traits::eq_int_type(__c, _Traits::eof()))
> {
> const size_t __n = __sbin->egptr() - __sbin->gptr();
> if (__n > 1)
> {
> const size_t __wrote = __sbout->sputn(__sbin->gptr(), __n);
> __sbin->gbump(__wrote);
> __ret += __wrote;
> if (__wrote < __n)
> break;
> __c = __sbin->underflow();
> }
> else
> {
> __c = __sbout->sputc(_Traits::to_char_type(__c));
> if (_Traits::eq_int_type(__c, _Traits::eof()))
> break;
> ++__ret;
> __c = __sbin->snextc();
> }
> }
> return __ret;
> }
>
>
>
>
>
> extern template class basic_streambuf<char>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<char>*, basic_streambuf<char>*);
>
>
> extern template class basic_streambuf<wchar_t>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<wchar_t>*, basic_streambuf<wchar_t>*);
>
>
>}
># 782 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/streambuf" 2 3
># 51 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/streambuf_iterator.h" 1 3
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/streambuf_iterator.h" 3
> 
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/streambuf_iterator.h" 3
>
>
>
>
>
>
>namespace std
>{
>
>
> 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;
>
>
> private:
>
>
>
>
>
>
>
> mutable streambuf_type* _M_sbuf;
> int_type _M_c;
>
> public:
>
> istreambuf_iterator() throw()
> : _M_sbuf(0), _M_c(traits_type::eof()) { }
>
>
> 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++()
> {
> ;
>
>
> const int_type __eof = traits_type::eof();
> if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof))
> _M_sbuf = 0;
> else
> _M_c = __eof;
> return *this;
> }
>
>
> istreambuf_iterator
> operator++(int)
> {
> ;
>
>
>
> const int_type __eof = traits_type::eof();
> istreambuf_iterator __old = *this;
> if (_M_sbuf
> && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()),
> __eof))
> _M_sbuf = 0;
> else
> _M_c = __eof;
> return __old;
> }
>
>
>
>
>
> bool
> equal(const istreambuf_iterator& __b) const
> {
> const bool __thiseof = _M_at_eof();
> const bool __beof = __b._M_at_eof();
> return (__thiseof && __beof || (!__thiseof && !__beof));
> }
>
> 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_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;
>
>
> 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;
> }
> };
>}
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwctype" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwctype" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwctype" 3
>
>
>
>
># 1 "/usr/include/wctype.h" 1 3 4
># 35 "/usr/include/wctype.h" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/stddef.h" 1 3 4
># 36 "/usr/include/wctype.h" 2 3 4
># 45 "/usr/include/wctype.h" 3 4
>
>
>
># 64 "/usr/include/wctype.h" 3 4
>
>
>
>typedef unsigned long int wctype_t;
>
># 86 "/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 ();
># 186 "/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 ();
>
>
>}
># 228 "/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 ();
>
>
>
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwctype" 2 3
># 79 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cwctype" 3
>namespace std
>{
> using ::wint_t;
>
> using ::wctype_t;
> using ::wctrans_t;
>
> using ::iswalnum;
> using ::iswalpha;
>
> using ::iswblank;
>
> using ::iswcntrl;
> using ::iswdigit;
> using ::iswgraph;
> using ::iswlower;
> using ::iswprint;
> using ::iswprint;
> using ::iswpunct;
> using ::iswspace;
> using ::iswupper;
> using ::iswxdigit;
> using ::iswctype;
> using ::towlower;
> using ::towupper;
> using ::towctrans;
> using ::wctrans;
> using ::wctype;
>}
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 2 3
>
>
>
>
>namespace std
>{
># 63 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _Tv>
> void
> __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
> const __c_locale& __cloc);
>
>
> template<>
> void
> __convert_to_v(const char*, float&, ios_base::iostate&,
> const __c_locale&);
>
> template<>
> void
> __convert_to_v(const char*, double&, ios_base::iostate&,
> const __c_locale&);
>
> template<>
> void
> __convert_to_v(const char*, long double&, ios_base::iostate&,
> const __c_locale&);
>
>
>
> template<typename _CharT, typename _Traits>
> struct __pad
> {
> static void
> _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
> const _CharT* __olds, const streamsize __newlen,
> const streamsize __oldlen, const bool __num);
> };
>
>
>
>
>
>
> 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;
> }
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/ctype_base.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/ctype_base.h" 3
> 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;
> };
># 133 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 2 3
># 144 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _CharT>
> class __ctype_abstract_base : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef _CharT char_type;
># 162 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> bool
> is(mask __m, char_type __c) const
> { return this->do_is(__m, __c); }
># 179 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 195 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 211 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 225 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 240 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 254 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 269 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 286 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> { return this->do_widen(__c); }
># 305 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 324 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return this->do_narrow(__c, __dfault); }
># 346 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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() { }
># 371 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const = 0;
># 390 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi,
> mask* __vec) const = 0;
># 409 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 428 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 446 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type) const = 0;
># 463 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const = 0;
># 479 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type) const = 0;
># 496 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const = 0;
># 515 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char) const = 0;
># 536 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi,
> char_type* __dest) const = 0;
># 558 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type, char __dfault) const = 0;
># 582 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __dest) const = 0;
> };
># 605 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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* __dest) const;
> };
>
> template<typename _CharT>
> locale::id ctype<_CharT>::id;
># 674 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
># 711 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
># 724 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
> size_t __refs = 0);
># 737 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> inline bool
> is(mask __m, char __c) const;
># 752 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> inline const char*
> is(const char* __lo, const char* __hi, mask* __vec) const;
># 766 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> inline const char*
> scan_is(mask __m, const char* __lo, const char* __hi) const;
># 780 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> inline const char*
> scan_not(mask __m, const char* __lo, const char* __hi) const;
># 795 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 812 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 828 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 845 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 865 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
> }
># 892 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> {
> if (_M_widen_ok == 1)
> {
> memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_widen_ok)
> _M_widen_init();
> return this->do_widen(__lo, __hi, __to);
> }
># 923 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 956 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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))
> {
> memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_narrow_ok)
> _M_narrow_init();
> return this->do_narrow(__lo, __hi, __dfault, __to);
> }
>
> protected:
>
>
> const mask*
> table() const throw()
> { return _M_table; }
>
>
> static const mask*
> classic_table() throw();
>
>
>
>
>
>
>
> virtual
> ~ctype();
># 1003 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type) const;
># 1020 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1036 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type) const;
># 1053 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1073 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const
> { return __c; }
># 1096 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const
> {
> memcpy(__dest, __lo, __hi - __lo);
> return __hi;
> }
># 1122 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char) const
> { return __c; }
># 1148 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char, char* __dest) const
> {
> memcpy(__dest, __lo, __hi - __lo);
> return __hi;
> }
>
> private:
>
> void _M_widen_init() const
> {
> char __tmp[sizeof(_M_widen)];
> for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
> __tmp[__i] = __i;
> do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);
>
> _M_widen_ok = 1;
>
> if (memcmp(__tmp, _M_widen, sizeof(_M_widen)))
> _M_widen_ok = 2;
> }
>
>
>
>
> void _M_narrow_init() const
> {
> char __tmp[sizeof(_M_narrow)];
> for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
> __tmp[__i] = __i;
> do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow);
>
> _M_narrow_ok = 1;
> if (memcmp(__tmp, _M_narrow, sizeof(_M_narrow)))
> _M_narrow_ok = 2;
> else
> {
>
>
> char __c;
> do_narrow(__tmp, __tmp + 1, 1, &__c);
> if (__c == 1)
> _M_narrow_ok = 2;
> }
> }
> };
>
> template<>
> const ctype<char>&
> use_facet<ctype<char> >(const locale& __loc);
># 1212 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 1245 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> ctype(size_t __refs = 0);
># 1256 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
>
> virtual
> ~ctype();
># 1280 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const;
># 1299 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
># 1317 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
># 1335 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
># 1352 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type) const;
># 1369 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1385 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type) const;
># 1402 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1422 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char) const;
># 1444 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
># 1467 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type, char __dfault) const;
># 1493 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __dest) const;
>
>
> void
> _M_initialize_ctype();
> };
>
> template<>
> const ctype<wchar_t>&
> use_facet<ctype<wchar_t> >(const locale& __loc);
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/ctype_inline.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/ctype_inline.h" 3
> 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;
> }
># 1509 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 2 3
>
>
> template<typename _CharT>
> class ctype_byname : public ctype<_CharT>
> {
> public:
> typedef _CharT char_type;
>
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname() { };
> };
>
>
> template<>
> ctype_byname<char>::ctype_byname(const char*, size_t refs);
>
> template<>
> ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 1 3
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
> 
># 45 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
>
>
>
> class codecvt_base
> {
> public:
> enum result
> {
> ok,
> partial,
> error,
> noconv
> };
> };
># 73 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
> template<typename _InternT, typename _ExternT, typename _StateT>
> class __codecvt_abstract_base
> : public locale::facet, public codecvt_base
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef _StateT state_type;
># 120 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
> result
> out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> {
> return this->do_out(__state, __from, __from_end, __from_next,
> __to, __to_end, __to_next);
> }
># 159 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
> result
> unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> { return this->do_unshift(__state, __to,__to_end,__to_next); }
># 199 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
> result
> in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const
> {
> return this->do_in(__state, __from, __from_end, __from_next,
> __to, __to_end, __to_next);
> }
>
> int
> encoding() const throw()
> { return this->do_encoding(); }
>
> bool
> always_noconv() const throw()
> { return this->do_always_noconv(); }
>
> int
> length(state_type& __state, const extern_type* __from,
> const extern_type* __end, size_t __max) const
> { return this->do_length(__state, __from, __end, __max); }
>
> int
> max_length() const throw()
> { return this->do_max_length(); }
>
> protected:
> explicit
> __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
>
> virtual
> ~__codecvt_abstract_base() { }
># 240 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 3
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const = 0;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const = 0;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const = 0;
>
> virtual int
> do_encoding() const throw() = 0;
>
> virtual bool
> do_always_noconv() const throw() = 0;
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const = 0;
>
> virtual int
> do_max_length() const throw() = 0;
> };
>
>
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt
> : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef _StateT state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0)
> : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt() { }
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> locale::id codecvt<_InternT, _ExternT, _StateT>::id;
>
>
> template<>
> class codecvt<char, char, mbstate_t>
> : public __codecvt_abstract_base<char, char, mbstate_t>
> {
> public:
>
> typedef char intern_type;
> typedef char extern_type;
> typedef mbstate_t state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0);
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt();
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
>
>
> template<>
> class codecvt<wchar_t, char, mbstate_t>
> : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
> {
> public:
>
> typedef wchar_t intern_type;
> typedef char extern_type;
> typedef mbstate_t state_type;
>
> protected:
> __c_locale _M_c_locale_codecvt;
>
> public:
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0);
>
> explicit
> codecvt(__c_locale __cloc, size_t __refs = 0);
>
> protected:
> virtual
> ~codecvt();
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state,
> const extern_type* __from, const extern_type* __from_end,
> const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual
> int do_encoding() const throw();
>
> virtual
> bool do_always_noconv() const throw();
>
> virtual
> int do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
>
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
> {
> public:
> explicit
> codecvt_byname(const char* __s, size_t __refs = 0)
> : codecvt<_InternT, _ExternT, _StateT>(__refs)
> {
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
> this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
> }
> }
>
> protected:
> virtual
> ~codecvt_byname() { }
> };
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/codecvt_specializations.h" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/codecvt_specializations.h" 3
> class __enc_traits
> {
> public:
>
>
>
> typedef iconv_t __desc_type;
>
> protected:
>
>
> static const int _S_max_size = 32;
>
> char _M_int_enc[_S_max_size];
>
> char _M_ext_enc[_S_max_size];
>
>
> __desc_type _M_in_desc;
>
> __desc_type _M_out_desc;
>
>
> int _M_ext_bom;
>
>
> int _M_int_bom;
>
> public:
> explicit __enc_traits()
> : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0)
> {
> memset(_M_int_enc, 0, _S_max_size);
> memset(_M_ext_enc, 0, _S_max_size);
> }
>
> explicit __enc_traits(const char* __int, const char* __ext,
> int __ibom = 0, int __ebom = 0)
> : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(__ebom), _M_int_bom(__ibom)
> {
> strncpy(_M_int_enc, __int, _S_max_size);
> strncpy(_M_ext_enc, __ext, _S_max_size);
> _M_init();
> }
># 99 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/codecvt_specializations.h" 3
> __enc_traits(const __enc_traits& __obj): _M_in_desc(0), _M_out_desc(0)
> {
> strncpy(_M_int_enc, __obj._M_int_enc, _S_max_size);
> strncpy(_M_ext_enc, __obj._M_ext_enc, _S_max_size);
> _M_ext_bom = __obj._M_ext_bom;
> _M_int_bom = __obj._M_int_bom;
> _M_destroy();
> _M_init();
> }
>
>
> __enc_traits&
> operator=(const __enc_traits& __obj)
> {
> strncpy(_M_int_enc, __obj._M_int_enc, _S_max_size);
> strncpy(_M_ext_enc, __obj._M_ext_enc, _S_max_size);
> _M_ext_bom = __obj._M_ext_bom;
> _M_int_bom = __obj._M_int_bom;
> _M_destroy();
> _M_init();
> return *this;
> }
>
> ~__enc_traits()
> { _M_destroy(); }
>
> void
> _M_init()
> {
> const __desc_type __err = reinterpret_cast<iconv_t>(-1);
> if (!_M_in_desc)
> {
> _M_in_desc = iconv_open(_M_int_enc, _M_ext_enc);
> if (_M_in_desc == __err)
> __throw_runtime_error(("__enc_traits::_M_init " "creating iconv input descriptor failed"));
>
> }
> if (!_M_out_desc)
> {
> _M_out_desc = iconv_open(_M_ext_enc, _M_int_enc);
> if (_M_out_desc == __err)
> __throw_runtime_error(("__enc_traits::_M_init " "creating iconv output descriptor failed"));
>
> }
> }
>
> void
> _M_destroy()
> {
> const __desc_type __err = reinterpret_cast<iconv_t>(-1);
> if (_M_in_desc && _M_in_desc != __err)
> {
> iconv_close(_M_in_desc);
> _M_in_desc = 0;
> }
> if (_M_out_desc && _M_out_desc != __err)
> {
> iconv_close(_M_out_desc);
> _M_out_desc = 0;
> }
> }
>
> bool
> _M_good()
> {
> const __desc_type __err = reinterpret_cast<iconv_t>(-1);
> bool __test = _M_in_desc && _M_in_desc != __err;
> __test &= _M_out_desc && _M_out_desc != __err;
> return __test;
> }
>
> const __desc_type*
> _M_get_in_descriptor()
> { return &_M_in_desc; }
>
> const __desc_type*
> _M_get_out_descriptor()
> { return &_M_out_desc; }
>
> int
> _M_get_external_bom()
> { return _M_ext_bom; }
>
> int
> _M_get_internal_bom()
> { return _M_int_bom; }
>
> const char*
> _M_get_internal_enc()
> { return _M_int_enc; }
>
> const char*
> _M_get_external_enc()
> { return _M_ext_enc; }
> };
>
>
>
>
> template<typename _InternT, typename _ExternT>
> class codecvt<_InternT, _ExternT, __enc_traits>
> : public __codecvt_abstract_base<_InternT, _ExternT, __enc_traits>
> {
> public:
>
> typedef codecvt_base::result result;
> typedef _InternT intern_type;
> typedef _ExternT extern_type;
> typedef __enc_traits state_type;
> typedef __enc_traits::__desc_type __desc_type;
> typedef __enc_traits __enc_type;
>
>
> static locale::id id;
>
> explicit
> codecvt(size_t __refs = 0)
> : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
> { }
>
> explicit
> codecvt(__enc_type* __enc, size_t __refs = 0)
> : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
> { }
>
> protected:
> virtual
> ~codecvt() { }
>
> virtual result
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const;
>
> virtual result
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const;
>
> virtual result
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const;
>
> virtual int
> do_encoding() const throw();
>
> virtual bool
> do_always_noconv() const throw();
>
> virtual int
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const;
>
> virtual int
> do_max_length() const throw();
> };
>
> template<typename _InternT, typename _ExternT>
> locale::id
> codecvt<_InternT, _ExternT, __enc_traits>::id;
>
>
>
>
>
> template<typename _T>
> inline size_t
> __iconv_adaptor(size_t(*__func)(iconv_t, _T, size_t*, char**, size_t*),
> iconv_t __cd, char** __inbuf, size_t* __inbytes,
> char** __outbuf, size_t* __outbytes)
> { return __func(__cd, (_T)__inbuf, __inbytes, __outbuf, __outbytes); }
>
> template<typename _InternT, typename _ExternT>
> codecvt_base::result
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_out(state_type& __state, const intern_type* __from,
> const intern_type* __from_end, const intern_type*& __from_next,
> extern_type* __to, extern_type* __to_end,
> extern_type*& __to_next) const
> {
> result __ret = codecvt_base::error;
> if (__state._M_good())
> {
> const __desc_type* __desc = __state._M_get_out_descriptor();
> const size_t __fmultiple = sizeof(intern_type);
> size_t __fbytes = __fmultiple * (__from_end - __from);
> const size_t __tmultiple = sizeof(extern_type);
> size_t __tbytes = __tmultiple * (__to_end - __to);
>
>
>
> char* __cto = reinterpret_cast<char*>(__to);
> char* __cfrom;
> size_t __conv;
>
>
>
>
>
>
> int __int_bom = __state._M_get_internal_bom();
> if (__int_bom)
> {
> size_t __size = __from_end - __from;
> intern_type* __cfixed = static_cast<intern_type*>
> (__builtin_alloca(sizeof(intern_type) * (__size + 1)));
> __cfixed[0] = static_cast<intern_type>(__int_bom);
> char_traits<intern_type>::copy(__cfixed + 1, __from, __size);
> __cfrom = reinterpret_cast<char*>(__cfixed);
> __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
> &__fbytes, &__cto, &__tbytes);
> }
> else
> {
> intern_type* __cfixed = const_cast<intern_type*>(__from);
> __cfrom = reinterpret_cast<char*>(__cfixed);
> __conv = __iconv_adaptor(iconv, *__desc, &__cfrom, &__fbytes,
> &__cto, &__tbytes);
> }
>
> if (__conv != size_t(-1))
> {
> __from_next = reinterpret_cast<const intern_type*>(__cfrom);
> __to_next = reinterpret_cast<extern_type*>(__cto);
> __ret = codecvt_base::ok;
> }
> else
> {
> if (__fbytes < __fmultiple * (__from_end - __from))
> {
> __from_next = reinterpret_cast<const intern_type*>(__cfrom);
> __to_next = reinterpret_cast<extern_type*>(__cto);
> __ret = codecvt_base::partial;
> }
> else
> __ret = codecvt_base::error;
> }
> }
> return __ret;
> }
>
> template<typename _InternT, typename _ExternT>
> codecvt_base::result
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_unshift(state_type& __state, extern_type* __to,
> extern_type* __to_end, extern_type*& __to_next) const
> {
> result __ret = codecvt_base::error;
> if (__state._M_good())
> {
> const __desc_type* __desc = __state._M_get_in_descriptor();
> const size_t __tmultiple = sizeof(intern_type);
> size_t __tlen = __tmultiple * (__to_end - __to);
>
>
>
> char* __cto = reinterpret_cast<char*>(__to);
> size_t __conv = __iconv_adaptor(iconv,*__desc, __null, __null,
> &__cto, &__tlen);
>
> if (__conv != size_t(-1))
> {
> __to_next = reinterpret_cast<extern_type*>(__cto);
> if (__tlen == __tmultiple * (__to_end - __to))
> __ret = codecvt_base::noconv;
> else if (__tlen == 0)
> __ret = codecvt_base::ok;
> else
> __ret = codecvt_base::partial;
> }
> else
> __ret = codecvt_base::error;
> }
> return __ret;
> }
>
> template<typename _InternT, typename _ExternT>
> codecvt_base::result
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_in(state_type& __state, const extern_type* __from,
> const extern_type* __from_end, const extern_type*& __from_next,
> intern_type* __to, intern_type* __to_end,
> intern_type*& __to_next) const
> {
> result __ret = codecvt_base::error;
> if (__state._M_good())
> {
> const __desc_type* __desc = __state._M_get_in_descriptor();
> const size_t __fmultiple = sizeof(extern_type);
> size_t __flen = __fmultiple * (__from_end - __from);
> const size_t __tmultiple = sizeof(intern_type);
> size_t __tlen = __tmultiple * (__to_end - __to);
>
>
>
> char* __cto = reinterpret_cast<char*>(__to);
> char* __cfrom;
> size_t __conv;
>
>
>
>
>
>
> int __ext_bom = __state._M_get_external_bom();
> if (__ext_bom)
> {
> size_t __size = __from_end - __from;
> extern_type* __cfixed = static_cast<extern_type*>
> (__builtin_alloca(sizeof(extern_type) * (__size + 1)));
> __cfixed[0] = static_cast<extern_type>(__ext_bom);
> char_traits<extern_type>::copy(__cfixed + 1, __from, __size);
> __cfrom = reinterpret_cast<char*>(__cfixed);
> __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
> &__flen, &__cto, &__tlen);
> }
> else
> {
> extern_type* __cfixed = const_cast<extern_type*>(__from);
> __cfrom = reinterpret_cast<char*>(__cfixed);
> __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
> &__flen, &__cto, &__tlen);
> }
>
>
> if (__conv != size_t(-1))
> {
> __from_next = reinterpret_cast<const extern_type*>(__cfrom);
> __to_next = reinterpret_cast<intern_type*>(__cto);
> __ret = codecvt_base::ok;
> }
> else
> {
> if (__flen < static_cast<size_t>(__from_end - __from))
> {
> __from_next = reinterpret_cast<const extern_type*>(__cfrom);
> __to_next = reinterpret_cast<intern_type*>(__cto);
> __ret = codecvt_base::partial;
> }
> else
> __ret = codecvt_base::error;
> }
> }
> return __ret;
> }
>
> template<typename _InternT, typename _ExternT>
> int
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_encoding() const throw()
> {
> int __ret = 0;
> if (sizeof(_ExternT) <= sizeof(_InternT))
> __ret = sizeof(_InternT)/sizeof(_ExternT);
> return __ret;
> }
>
> template<typename _InternT, typename _ExternT>
> bool
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_always_noconv() const throw()
> { return false; }
>
> template<typename _InternT, typename _ExternT>
> int
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_length(state_type&, const extern_type* __from,
> const extern_type* __end, size_t __max) const
> { return std::min(__max, static_cast<size_t>(__end - __from)); }
>
>
>
> template<typename _InternT, typename _ExternT>
> int
> codecvt<_InternT, _ExternT, __enc_traits>::
> do_max_length() const throw()
> { return 1; }
># 476 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/codecvt.h" 2 3
># 1534 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 2 3
>
>
> 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);
> };
>
> 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(__null), _M_grouping_size(0), _M_use_grouping(false),
> _M_truename(__null), _M_truename_size(0), _M_falsename(__null),
> _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;
> }
> }
># 1656 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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(__null)
> { _M_initialize_numpunct(); }
># 1693 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> numpunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_numpunct(); }
># 1707 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> numpunct(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_data(__null)
> { _M_initialize_numpunct(__cloc); }
># 1721 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 1734 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 1765 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 1778 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> truename() const
> { return this->do_truename(); }
># 1791 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> falsename() const
> { return this->do_falsename(); }
>
> protected:
>
> virtual
> ~numpunct();
># 1808 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 1820 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 1833 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 1846 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_truename() const
> { return _M_data->_M_truename; }
># 1859 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_falsename() const
> { return _M_data->_M_falsename; }
>
>
> void
> _M_initialize_numpunct(__c_locale __cloc = __null);
> };
>
> 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 (std::strcmp(__s, "C") != 0 && std::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() { }
> };
># 1924 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 1945 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> num_get(size_t __refs = 0) : facet(__refs) { }
># 1971 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 2007 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 2066 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 2108 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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& __xtrc) const;
>
> template<typename _ValueT>
> iter_type
> _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
> _ValueT& __v) const;
># 2141 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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, iter_type, ios_base&, ios_base::iostate&, long&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned short&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned int&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned long&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> long long&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> unsigned long long&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> float&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> double&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> long double&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
> void*&) const;
>
> };
>
> template<typename _CharT, typename _InIter>
> locale::id num_get<_CharT, _InIter>::id;
># 2203 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
># 2224 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> num_put(size_t __refs = 0) : facet(__refs) { }
># 2242 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
> { return this->do_put(__s, __f, __fill, __v); }
># 2284 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> unsigned long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> unsigned long long __v) const
> { return this->do_put(__s, __f, __fill, __v); }
># 2347 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
> { return this->do_put(__s, __f, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> long double __v) const
> { return this->do_put(__s, __f, __fill, __v); }
># 2372 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __f, char_type __fill,
> const void* __v) const
> { return this->do_put(__s, __f, __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() { };
># 2420 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, long __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, long long __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, double __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
>
> };
>
> template <typename _CharT, typename _OutIter>
> locale::id num_put<_CharT, _OutIter>::id;
># 2464 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.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;
># 2491 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> collate(size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
> { }
># 2505 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> collate(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
> { }
># 2522 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.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); }
># 2541 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> transform(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_transform(__lo, __hi); }
># 2555 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.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;
>
> size_t
> _M_transform(_CharT*, const _CharT*, size_t) const;
>
> protected:
>
> virtual
> ~collate()
> { _S_destroy_c_locale(_M_c_locale_collate); }
># 2584 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual int
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const;
># 2600 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_transform(const _CharT* __lo, const _CharT* __hi) const;
># 2613 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.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;
>
> template<>
> size_t
> collate<char>::_M_transform(char*, const char*, size_t) const;
>
>
> template<>
> int
> collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;
>
> template<>
> size_t
> collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;
>
>
> 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 (std::strcmp(__s, "C") != 0 && std::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() { }
> };
># 2672 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> class time_base
> {
> public:
> enum dateorder { no_order, dmy, mdy, ymd, ydm };
> };
>
> template<typename _CharT>
> struct __timepunct_cache : public locale::facet
> {
>
> static const _CharT* _S_timezones[14];
>
> const _CharT* _M_date_format;
> const _CharT* _M_date_era_format;
> const _CharT* _M_time_format;
> const _CharT* _M_time_era_format;
> const _CharT* _M_date_time_format;
> const _CharT* _M_date_time_era_format;
> const _CharT* _M_am;
> const _CharT* _M_pm;
> const _CharT* _M_am_pm_format;
>
>
> const _CharT* _M_day1;
> const _CharT* _M_day2;
> const _CharT* _M_day3;
> const _CharT* _M_day4;
> const _CharT* _M_day5;
> const _CharT* _M_day6;
> const _CharT* _M_day7;
>
>
> const _CharT* _M_aday1;
> const _CharT* _M_aday2;
> const _CharT* _M_aday3;
> const _CharT* _M_aday4;
> const _CharT* _M_aday5;
> const _CharT* _M_aday6;
> const _CharT* _M_aday7;
>
>
> const _CharT* _M_month01;
> const _CharT* _M_month02;
> const _CharT* _M_month03;
> const _CharT* _M_month04;
> const _CharT* _M_month05;
> const _CharT* _M_month06;
> const _CharT* _M_month07;
> const _CharT* _M_month08;
> const _CharT* _M_month09;
> const _CharT* _M_month10;
> const _CharT* _M_month11;
> const _CharT* _M_month12;
>
>
> const _CharT* _M_amonth01;
> const _CharT* _M_amonth02;
> const _CharT* _M_amonth03;
> const _CharT* _M_amonth04;
> const _CharT* _M_amonth05;
> const _CharT* _M_amonth06;
> const _CharT* _M_amonth07;
> const _CharT* _M_amonth08;
> const _CharT* _M_amonth09;
> const _CharT* _M_amonth10;
> const _CharT* _M_amonth11;
> const _CharT* _M_amonth12;
>
> bool _M_allocated;
>
> __timepunct_cache(size_t __refs = 0) : facet(__refs),
> _M_date_format(__null), _M_date_era_format(__null), _M_time_format(__null),
> _M_time_era_format(__null), _M_date_time_format(__null),
> _M_date_time_era_format(__null), _M_am(__null), _M_pm(__null),
> _M_am_pm_format(__null), _M_day1(__null), _M_day2(__null), _M_day3(__null),
> _M_day4(__null), _M_day5(__null), _M_day6(__null), _M_day7(__null),
> _M_aday1(__null), _M_aday2(__null), _M_aday3(__null), _M_aday4(__null),
> _M_aday5(__null), _M_aday6(__null), _M_aday7(__null), _M_month01(__null),
> _M_month02(__null), _M_month03(__null), _M_month04(__null), _M_month05(__null),
> _M_month06(__null), _M_month07(__null), _M_month08(__null), _M_month09(__null),
> _M_month10(__null), _M_month11(__null), _M_month12(__null), _M_amonth01(__null),
> _M_amonth02(__null), _M_amonth03(__null), _M_amonth04(__null),
> _M_amonth05(__null), _M_amonth06(__null), _M_amonth07(__null),
> _M_amonth08(__null), _M_amonth09(__null), _M_amonth10(__null),
> _M_amonth11(__null), _M_amonth12(__null), _M_allocated(false)
> { }
>
> ~__timepunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __timepunct_cache&
> operator=(const __timepunct_cache&);
>
> explicit
> __timepunct_cache(const __timepunct_cache&);
> };
>
> template<typename _CharT>
> __timepunct_cache<_CharT>::~__timepunct_cache()
> {
> if (_M_allocated)
> {
>
> }
> }
>
>
> template<>
> const char*
> __timepunct_cache<char>::_S_timezones[14];
>
>
> template<>
> const wchar_t*
> __timepunct_cache<wchar_t>::_S_timezones[14];
>
>
>
> template<typename _CharT>
> const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
>
> template<typename _CharT>
> class __timepunct : public locale::facet
> {
> public:
>
> typedef _CharT __char_type;
> typedef basic_string<_CharT> __string_type;
> typedef __timepunct_cache<_CharT> __cache_type;
>
> protected:
> __cache_type* _M_data;
> __c_locale _M_c_locale_timepunct;
> const char* _M_name_timepunct;
>
> public:
>
> static locale::id id;
>
> explicit
> __timepunct(size_t __refs = 0);
>
> explicit
> __timepunct(__cache_type* __cache, size_t __refs = 0);
># 2830 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
>
> void
> _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
> const tm* __tm) const;
>
> void
> _M_date_formats(const _CharT** __date) const
> {
>
> __date[0] = _M_data->_M_date_format;
> __date[1] = _M_data->_M_date_era_format;
> }
>
> void
> _M_time_formats(const _CharT** __time) const
> {
>
> __time[0] = _M_data->_M_time_format;
> __time[1] = _M_data->_M_time_era_format;
> }
>
> void
> _M_date_time_formats(const _CharT** __dt) const
> {
>
> __dt[0] = _M_data->_M_date_time_format;
> __dt[1] = _M_data->_M_date_time_era_format;
> }
>
> void
> _M_am_pm_format(const _CharT* __ampm) const
> { __ampm = _M_data->_M_am_pm_format; }
>
> void
> _M_am_pm(const _CharT** __ampm) const
> {
> __ampm[0] = _M_data->_M_am;
> __ampm[1] = _M_data->_M_pm;
> }
>
> void
> _M_days(const _CharT** __days) const
> {
> __days[0] = _M_data->_M_day1;
> __days[1] = _M_data->_M_day2;
> __days[2] = _M_data->_M_day3;
> __days[3] = _M_data->_M_day4;
> __days[4] = _M_data->_M_day5;
> __days[5] = _M_data->_M_day6;
> __days[6] = _M_data->_M_day7;
> }
>
> void
> _M_days_abbreviated(const _CharT** __days) const
> {
> __days[0] = _M_data->_M_aday1;
> __days[1] = _M_data->_M_aday2;
> __days[2] = _M_data->_M_aday3;
> __days[3] = _M_data->_M_aday4;
> __days[4] = _M_data->_M_aday5;
> __days[5] = _M_data->_M_aday6;
> __days[6] = _M_data->_M_aday7;
> }
>
> void
> _M_months(const _CharT** __months) const
> {
> __months[0] = _M_data->_M_month01;
> __months[1] = _M_data->_M_month02;
> __months[2] = _M_data->_M_month03;
> __months[3] = _M_data->_M_month04;
> __months[4] = _M_data->_M_month05;
> __months[5] = _M_data->_M_month06;
> __months[6] = _M_data->_M_month07;
> __months[7] = _M_data->_M_month08;
> __months[8] = _M_data->_M_month09;
> __months[9] = _M_data->_M_month10;
> __months[10] = _M_data->_M_month11;
> __months[11] = _M_data->_M_month12;
> }
>
> void
> _M_months_abbreviated(const _CharT** __months) const
> {
> __months[0] = _M_data->_M_amonth01;
> __months[1] = _M_data->_M_amonth02;
> __months[2] = _M_data->_M_amonth03;
> __months[3] = _M_data->_M_amonth04;
> __months[4] = _M_data->_M_amonth05;
> __months[5] = _M_data->_M_amonth06;
> __months[6] = _M_data->_M_amonth07;
> __months[7] = _M_data->_M_amonth08;
> __months[8] = _M_data->_M_amonth09;
> __months[9] = _M_data->_M_amonth10;
> __months[10] = _M_data->_M_amonth11;
> __months[11] = _M_data->_M_amonth12;
> }
>
> protected:
> virtual
> ~__timepunct();
>
>
> void
> _M_initialize_timepunct(__c_locale __cloc = __null);
> };
>
> template<typename _CharT>
> locale::id __timepunct<_CharT>::id;
>
>
> template<>
> void
> __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
>
> template<>
> void
> __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;
>
>
> template<>
> void
> __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
>
> template<>
> void
> __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
> const tm*) const;
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/time_members.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/time_members.h" 3
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(size_t __refs)
> : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
> _M_name_timepunct(_S_get_c_name())
> { _M_initialize_timepunct(); }
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
> : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(__null),
> _M_name_timepunct(_S_get_c_name())
> { _M_initialize_timepunct(); }
>
> template<typename _CharT>
> __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
> size_t __refs)
> : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
> _M_name_timepunct(__s)
> {
> char* __tmp = new char[std::strlen(__s) + 1];
> std::strcpy(__tmp, __s);
> _M_name_timepunct = __tmp;
> _M_initialize_timepunct(__cloc);
> }
>
> template<typename _CharT>
> __timepunct<_CharT>::~__timepunct()
> {
> if (_M_name_timepunct != _S_get_c_name())
> delete [] _M_name_timepunct;
> delete _M_data;
> _S_destroy_c_locale(_M_c_locale_timepunct);
> }
># 2964 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 2 3
># 2977 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class time_get : public locale::facet, public time_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
> typedef basic_string<_CharT> __string_type;
>
>
> static locale::id id;
># 2999 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> time_get(size_t __refs = 0)
> : facet (__refs) { }
># 3016 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> dateorder
> date_order() const
> { return this->do_date_order(); }
># 3040 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_time(__beg, __end, __io, __err, __tm); }
># 3065 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_date(__beg, __end, __io, __err, __tm); }
># 3093 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
># 3122 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
># 3148 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> { return this->do_get_year(__beg, __end, __io, __err, __tm); }
>
> protected:
>
> virtual
> ~time_get() { }
># 3168 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual dateorder
> do_date_order() const;
># 3186 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
># 3205 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
># 3224 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
> ios_base::iostate& __err, tm* __tm) const;
># 3243 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
> ios_base::iostate& __err, tm* __tm) const;
># 3262 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const;
>
>
> iter_type
> _M_extract_num(iter_type __beg, iter_type __end, int& __member,
> int __min, int __max, size_t __len,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
>
> iter_type
> _M_extract_name(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const;
>
>
> iter_type
> _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm,
> const _CharT* __format) const;
> };
>
> template<typename _CharT, typename _InIter>
> locale::id time_get<_CharT, _InIter>::id;
>
> template<typename _CharT, typename _InIter>
> class time_get_byname : public time_get<_CharT, _InIter>
> {
> public:
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
> explicit
> time_get_byname(const char*, size_t __refs = 0)
> : time_get<_CharT, _InIter>(__refs) { }
>
> protected:
> virtual
> ~time_get_byname() { }
> };
># 3317 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class time_put : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
>
>
> static locale::id id;
># 3338 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> time_put(size_t __refs = 0)
> : facet(__refs) { }
># 3357 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> const _CharT* __beg, const _CharT* __end) const;
># 3377 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> const tm* __tm, char __format, char __mod = 0) const
> { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
>
> protected:
>
> virtual
> ~time_put()
> { }
># 3404 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> char __format, char __mod) const;
> };
>
> template<typename _CharT, typename _OutIter>
> locale::id time_put<_CharT, _OutIter>::id;
>
> template<typename _CharT, typename _OutIter>
> class time_put_byname : public time_put<_CharT, _OutIter>
> {
> public:
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
> explicit
> time_put_byname(const char*, size_t __refs = 0)
> : time_put<_CharT, _OutIter>(__refs)
> { };
>
> protected:
> virtual
> ~time_put_byname() { }
> };
># 3441 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> class money_base
> {
> public:
> enum part { none, space, symbol, sign, value };
> struct pattern { char field[4]; };
>
> static const pattern _S_default_pattern;
>
> enum
> {
> _S_minus,
> _S_zero,
> _S_end = 11
> };
>
>
>
> static const char* _S_atoms;
>
>
>
> static pattern
> _S_construct_pattern(char __precedes, char __space, char __posn);
> };
>
> template<typename _CharT, bool _Intl>
> struct __moneypunct_cache : public locale::facet
> {
> const char* _M_grouping;
> size_t _M_grouping_size;
> bool _M_use_grouping;
> _CharT _M_decimal_point;
> _CharT _M_thousands_sep;
> const _CharT* _M_curr_symbol;
> size_t _M_curr_symbol_size;
> const _CharT* _M_positive_sign;
> size_t _M_positive_sign_size;
> const _CharT* _M_negative_sign;
> size_t _M_negative_sign_size;
> int _M_frac_digits;
> money_base::pattern _M_pos_format;
> money_base::pattern _M_neg_format;
>
>
>
>
> _CharT _M_atoms[money_base::_S_end];
>
> bool _M_allocated;
>
> __moneypunct_cache(size_t __refs = 0) : facet(__refs),
> _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
> _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
> _M_curr_symbol(__null), _M_curr_symbol_size(0),
> _M_positive_sign(__null), _M_positive_sign_size(0),
> _M_negative_sign(__null), _M_negative_sign_size(0),
> _M_frac_digits(0),
> _M_pos_format(money_base::pattern()),
> _M_neg_format(money_base::pattern()), _M_allocated(false)
> { }
>
> ~__moneypunct_cache();
>
> void
> _M_cache(const locale& __loc);
>
> private:
> __moneypunct_cache&
> operator=(const __moneypunct_cache&);
>
> explicit
> __moneypunct_cache(const __moneypunct_cache&);
> };
>
> template<typename _CharT, bool _Intl>
> __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
> {
> if (_M_allocated)
> {
> delete [] _M_grouping;
> delete [] _M_curr_symbol;
> delete [] _M_positive_sign;
> delete [] _M_negative_sign;
> }
> }
>
>
>
>
>
>
>
> template<typename _CharT, bool _Intl>
> class moneypunct : public locale::facet, public money_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
>
> private:
> __cache_type* _M_data;
>
> public:
>
>
> static const bool intl = _Intl;
>
> static locale::id id;
># 3562 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
> { _M_initialize_moneypunct(); }
># 3574 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> moneypunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_moneypunct(); }
># 3589 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
> : facet(__refs), _M_data(__null)
> { _M_initialize_moneypunct(__cloc, __s); }
># 3603 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 3616 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 3645 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 3658 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> curr_symbol() const
> { return this->do_curr_symbol(); }
># 3675 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> positive_sign() const
> { return this->do_positive_sign(); }
># 3692 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> negative_sign() const
> { return this->do_negative_sign(); }
># 3708 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> int
> frac_digits() const
> { return this->do_frac_digits(); }
># 3743 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> pattern
> pos_format() const
> { return this->do_pos_format(); }
>
> pattern
> neg_format() const
> { return this->do_neg_format(); }
>
>
> protected:
>
> virtual
> ~moneypunct();
># 3765 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 3777 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 3790 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 3803 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_curr_symbol() const
> { return _M_data->_M_curr_symbol; }
># 3816 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_positive_sign() const
> { return _M_data->_M_positive_sign; }
># 3829 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_negative_sign() const
> { return _M_data->_M_negative_sign; }
># 3843 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual int
> do_frac_digits() const
> { return _M_data->_M_frac_digits; }
># 3857 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual pattern
> do_pos_format() const
> { return _M_data->_M_pos_format; }
># 3871 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual pattern
> do_neg_format() const
> { return _M_data->_M_neg_format; }
>
>
> void
> _M_initialize_moneypunct(__c_locale __cloc = __null,
> const char* __name = __null);
> };
>
> template<typename _CharT, bool _Intl>
> locale::id moneypunct<_CharT, _Intl>::id;
>
> template<typename _CharT, bool _Intl>
> const bool moneypunct<_CharT, _Intl>::intl;
>
> template<>
> moneypunct<char, true>::~moneypunct();
>
> template<>
> moneypunct<char, false>::~moneypunct();
>
> template<>
> void
> moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
>
> template<>
> void
> moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
>
>
> template<>
> moneypunct<wchar_t, true>::~moneypunct();
>
> template<>
> moneypunct<wchar_t, false>::~moneypunct();
>
> template<>
> void
> moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
> const char*);
>
> template<>
> void
> moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
> const char*);
>
>
> template<typename _CharT, bool _Intl>
> class moneypunct_byname : public moneypunct<_CharT, _Intl>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> static const bool intl = _Intl;
>
> explicit
> moneypunct_byname(const char* __s, size_t __refs = 0)
> : moneypunct<_CharT, _Intl>(__refs)
> {
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> __c_locale __tmp;
> this->_S_create_c_locale(__tmp, __s);
> this->_M_initialize_moneypunct(__tmp);
> this->_S_destroy_c_locale(__tmp);
> }
> }
>
> protected:
> virtual
> ~moneypunct_byname() { }
> };
>
> template<typename _CharT, bool _Intl>
> const bool moneypunct_byname<_CharT, _Intl>::intl;
># 3961 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class money_get : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
> typedef basic_string<_CharT> string_type;
>
>
>
> static locale::id id;
># 3983 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> money_get(size_t __refs = 0) : facet(__refs) { }
># 4013 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const
> { return this->do_get(__s, __end, __intl, __io, __err, __units); }
># 4043 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const
> { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
>
> protected:
>
> virtual
> ~money_get() { }
># 4060 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const;
># 4071 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __digits) const;
>
> template<bool _Intl>
> iter_type
> _M_extract(iter_type __s, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, string& __digits) const;
> };
>
> template<typename _CharT, typename _InIter>
> locale::id money_get<_CharT, _InIter>::id;
># 4096 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class money_put : public locale::facet
> {
> public:
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
> typedef basic_string<_CharT> string_type;
>
>
>
> static locale::id id;
># 4117 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> money_put(size_t __refs = 0) : facet(__refs) { }
># 4137 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, bool __intl, ios_base& __io,
> char_type __fill, long double __units) const
> { return this->do_put(__s, __intl, __io, __fill, __units); }
># 4159 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, bool __intl, ios_base& __io,
> char_type __fill, const string_type& __digits) const
> { return this->do_put(__s, __intl, __io, __fill, __digits); }
>
> protected:
>
> virtual
> ~money_put() { }
># 4187 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> long double __units) const;
># 4209 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> const string_type& __digits) const;
>
> template<bool _Intl>
> iter_type
> _M_insert(iter_type __s, ios_base& __io, char_type __fill,
> const string_type& __digits) const;
> };
>
> template<typename _CharT, typename _OutIter>
> locale::id money_put<_CharT, _OutIter>::id;
>
>
>
>
> struct messages_base
> {
> typedef int catalog;
> };
># 4250 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> template<typename _CharT>
> class messages : public locale::facet, public messages_base
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> protected:
>
>
> __c_locale _M_c_locale_messages;
> const char* _M_name_messages;
>
> public:
>
> static locale::id id;
># 4278 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> messages(size_t __refs = 0);
># 4292 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> explicit
> messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
># 4305 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> catalog
> open(const basic_string<char>& __s, const locale& __loc) const
> { return this->do_open(__s, __loc); }
># 4323 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> catalog
> open(const basic_string<char>&, const locale&, const char*) const;
># 4341 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> string_type
> get(catalog __c, int __set, int __msgid, const string_type& __s) const
> { return this->do_get(__c, __set, __msgid, __s); }
># 4352 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> void
> close(catalog __c) const
> { return this->do_close(__c); }
>
> protected:
>
> virtual
> ~messages();
># 4372 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual catalog
> do_open(const basic_string<char>&, const locale&) const;
># 4391 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> virtual string_type
> do_get(catalog, int, int, const string_type& __dfault) const;
>
>
>
>
>
>
> virtual void
> do_close(catalog) const;
>
>
> char*
> _M_convert_to_char(const string_type& __msg) const
> {
>
> return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
> }
>
>
> string_type
> _M_convert_from_char(char*) const
> {
># 4448 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> return string_type();
> }
> };
>
> template<typename _CharT>
> locale::id messages<_CharT>::id;
>
>
> template<>
> string
> messages<char>::do_get(catalog, int, int, const string&) const;
>
>
> template<>
> wstring
> messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
>
>
> template<typename _CharT>
> class messages_byname : public messages<_CharT>
> {
> public:
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
> explicit
> messages_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~messages_byname()
> { }
> };
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/messages_members.h" 1 3
># 37 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/i386-redhat-linux/bits/messages_members.h" 3
> template<typename _CharT>
> messages<_CharT>::messages(size_t __refs)
> : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
> _M_name_messages(_S_get_c_name())
> { }
>
> template<typename _CharT>
> messages<_CharT>::messages(__c_locale __cloc, const char* __s,
> size_t __refs)
> : facet(__refs), _M_c_locale_messages(_S_clone_c_locale(__cloc)),
> _M_name_messages(__s)
> {
> char* __tmp = new char[std::strlen(__s) + 1];
> std::strcpy(__tmp, __s);
> _M_name_messages = __tmp;
> }
>
> template<typename _CharT>
> typename messages<_CharT>::catalog
> messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
> const char* __dir) const
> {
> bindtextdomain(__s.c_str(), __dir);
> return this->do_open(__s, __loc);
> }
>
>
> template<typename _CharT>
> messages<_CharT>::~messages()
> {
> if (_M_name_messages != _S_get_c_name())
> delete [] _M_name_messages;
> _S_destroy_c_locale(_M_c_locale_messages);
> }
>
> template<typename _CharT>
> typename messages<_CharT>::catalog
> messages<_CharT>::do_open(const basic_string<char>& __s,
> const locale&) const
> {
>
>
> textdomain(__s.c_str());
> return 0;
> }
>
> template<typename _CharT>
> void
> messages<_CharT>::do_close(catalog) const
> { }
>
>
> template<typename _CharT>
> messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
> : messages<_CharT>(__refs)
> {
> if (this->_M_name_messages != locale::facet::_S_get_c_name())
> delete [] this->_M_name_messages;
> char* __tmp = new char[std::strlen(__s) + 1];
> std::strcpy(__tmp, __s);
> this->_M_name_messages = __tmp;
>
> if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_messages);
> this->_S_create_c_locale(this->_M_c_locale_messages, __s);
> }
> }
># 4484 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 2 3
># 4492 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.h" 3
> 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); }
>
>}
># 45 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 2 3
>
>namespace std
>{
>
>
>
>
>
>
>
> 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;
># 78 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> 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(); }
># 122 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> iostate
> rdstate() const
> { return _M_streambuf_state; }
># 133 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 186 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> bool
> fail() const
> { return (this->rdstate() & (badbit | failbit)) != 0; }
>
>
>
>
>
>
>
> bool
> bad() const
> { return (this->rdstate() & badbit) != 0; }
># 207 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> iostate
> exceptions() const
> { return _M_exception; }
># 242 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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() { }
># 280 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie() const
> { return _M_tie; }
># 292 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 332 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> basic_streambuf<_CharT, _Traits>*
> rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
># 346 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 375 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> char_type
> fill(char_type __ch)
> {
> char_type __old = this->fill();
> _M_fill = __ch;
> return __old;
> }
># 395 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> locale
> imbue(const locale& __loc);
># 415 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> char
> narrow(char_type __c, char __dfault) const;
># 433 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 3
> char_type
> widen(char __c) const;
>
> 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/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.tcc" 1 3
># 33 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.tcc" 3
> 
># 34 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.tcc" 3
>
>namespace std
>{
> 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];
> if (_M_word != _M_local_word)
> {
> delete [] _M_word;
> _M_word = 0;
> }
> _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>
> char
> basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
> { return __check_facet(_M_ctype).narrow(__c, __dfault); }
>
> template<typename _CharT, typename _Traits>
> _CharT
> basic_ios<_CharT, _Traits>::widen(char __c) const
> { return __check_facet(_M_ctype).widen(__c); }
>
>
> 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);
># 159 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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>;
>
>
>}
># 465 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/basic_ios.h" 2 3
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ios" 2 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 2 3
>
>
>namespace std
>{
># 58 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
> protected:
>
>
>
>
>
>
>
> streamsize _M_gcount;
>
> public:
># 104 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> 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;
># 131 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> inline __istream_type&
> operator>>(__istream_type& (*__pf)(__istream_type&));
>
> inline __istream_type&
> operator>>(__ios_type& (*__pf)(__ios_type&));
>
> inline __istream_type&
> operator>>(ios_base& (*__pf)(ios_base&));
># 169 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> operator>>(bool& __n);
>
> __istream_type&
> operator>>(short& __n);
>
> __istream_type&
> operator>>(unsigned short& __n);
>
> __istream_type&
> operator>>(int& __n);
>
> __istream_type&
> operator>>(unsigned int& __n);
>
> __istream_type&
> operator>>(long& __n);
>
> __istream_type&
> operator>>(unsigned long& __n);
>
>
> __istream_type&
> operator>>(long long& __n);
>
> __istream_type&
> operator>>(unsigned long long& __n);
>
>
> __istream_type&
> operator>>(float& __f);
>
> __istream_type&
> operator>>(double& __f);
>
> __istream_type&
> operator>>(long double& __f);
>
> __istream_type&
> operator>>(void*& __p);
># 230 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> operator>>(__streambuf_type* __sb);
># 240 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> inline streamsize
> gcount() const
> { return _M_gcount; }
># 272 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> int_type
> get();
># 286 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> get(char_type& __c);
># 313 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n, char_type __delim);
># 324 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> inline __istream_type&
> get(char_type* __s, streamsize __n)
> { return this->get(__s, __n, this->widen('\n')); }
># 347 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> get(__streambuf_type& __sb, char_type __delim);
># 357 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> inline __istream_type&
> get(__streambuf_type& __sb)
> { return this->get(__sb, this->widen('\n')); }
># 386 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n, char_type __delim);
># 397 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> inline __istream_type&
> getline(char_type* __s, streamsize __n)
> { return this->getline(__s, __n, this->widen('\n')); }
># 416 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> ignore(streamsize __n = 1, int_type __delim = traits_type::eof());
># 427 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> int_type
> peek();
># 445 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> read(char_type* __s, streamsize __n);
># 464 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> streamsize
> readsome(char_type* __s, streamsize __n);
># 480 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> putback(char_type __c);
># 495 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> unget();
># 513 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> int
> sync();
># 527 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> pos_type
> tellg();
># 542 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> seekg(pos_type);
># 558 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> __istream_type&
> seekg(off_type, ios_base::seekdir);
>
>
> protected:
> explicit
> basic_istream(): _M_gcount(streamsize(0)) { }
> };
># 578 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream<_CharT, _Traits>::sentry
> {
> 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;
># 610 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> explicit
> sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
># 620 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> operator bool() const { return _M_ok; }
>
> private:
> bool _M_ok;
> };
># 639 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
>
> template<class _Traits>
> basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
>
> template<class _Traits>
> basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
># 680 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
>
> template<class _Traits>
> basic_istream<char,_Traits>&
> operator>>(basic_istream<char,_Traits>& __in, unsigned char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
>
> template<class _Traits>
> basic_istream<char,_Traits>&
> operator>>(basic_istream<char,_Traits>& __in, signed char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
># 702 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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(), __ostream_type()
> { this->init(__sb); }
>
>
>
>
> virtual
> ~basic_iostream() { }
>
> protected:
> explicit
> basic_iostream() : __istream_type(), __ostream_type()
> { }
> };
># 765 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __is);
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/istream.tcc" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/istream.tcc" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/istream.tcc" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/locale" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/locale" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/locale" 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 3
> 
># 37 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/typeinfo" 1 3
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/typeinfo" 3
>extern "C++" {
>
>namespace __cxxabiv1
>{
> class __class_type_info;
>}
># 55 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/typeinfo" 3
>namespace std
>{
>
>
>
>
>
>
> class type_info
> {
> public:
>
>
>
>
> virtual ~type_info();
>
> private:
>
> type_info& operator=(const type_info&);
> type_info(const type_info&);
>
> protected:
> const char *__name;
>
> protected:
> explicit type_info(const char *__n): __name(__n) { }
>
> public:
>
>
>
> const char* name() const
> { return __name; }
># 101 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/typeinfo" 3
> bool before(const type_info& __arg) const
> { return __name < __arg.__name; }
> bool operator==(const type_info& __arg) const
> { return __name == __arg.__name; }
>
> bool operator!=(const type_info& __arg) const
> { return !operator==(__arg); }
>
>
> public:
>
> virtual bool __is_pointer_p() const;
>
> virtual bool __is_function_p() const;
>
>
>
>
>
>
>
> virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
> unsigned __outer) const;
>
>
> virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
> void **__obj_ptr) const;
> };
>
>
>
>
>
>
> class bad_cast : public exception
> {
> public:
> bad_cast() throw() { }
>
>
> virtual ~bad_cast() throw();
> };
>
>
> class bad_typeid : public exception
> {
> public:
> bad_typeid () throw() { }
>
>
> virtual ~bad_typeid() throw();
> };
>}
>
>}
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 2 3
>
>
>namespace std
>{
> 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);
> }
># 83 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 3
> template<typename _Facet>
> inline 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 && __facets[__i]);
> }
># 105 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 3
> template<typename _Facet>
> inline 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 static_cast<const _Facet&>(*__facets[__i]);
> }
>
>
>
> 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 = __null;
> 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, bool _Intl>
> struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
> {
> const __moneypunct_cache<_CharT, _Intl>*
> operator() (const locale& __loc) const
> {
> const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __moneypunct_cache<_CharT, _Intl>* __tmp = __null;
> try
> {
> __tmp = new __moneypunct_cache<_CharT, _Intl>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<
> const __moneypunct_cache<_CharT, _Intl>*>(__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);
>
> _M_grouping_size = __np.grouping().size();
> char* __grouping = new char[_M_grouping_size];
> __np.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = _M_grouping_size && __np.grouping()[0] != 0;
>
> _M_truename_size = __np.truename().size();
> _CharT* __truename = new _CharT[_M_truename_size];
> __np.truename().copy(__truename, _M_truename_size);
> _M_truename = __truename;
>
> _M_falsename_size = __np.falsename().size();
> _CharT* __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);
> }
>
> template<typename _CharT, bool _Intl>
> void
> __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
> {
> _M_allocated = true;
>
> const moneypunct<_CharT, _Intl>& __mp =
> use_facet<moneypunct<_CharT, _Intl> >(__loc);
>
> _M_grouping_size = __mp.grouping().size();
> char* __grouping = new char[_M_grouping_size];
> __mp.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = _M_grouping_size && __mp.grouping()[0] != 0;
>
> _M_decimal_point = __mp.decimal_point();
> _M_thousands_sep = __mp.thousands_sep();
> _M_frac_digits = __mp.frac_digits();
>
> _M_curr_symbol_size = __mp.curr_symbol().size();
> _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
> __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
> _M_curr_symbol = __curr_symbol;
>
> _M_positive_sign_size = __mp.positive_sign().size();
> _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
> __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
> _M_positive_sign = __positive_sign;
>
> _M_negative_sign_size = __mp.negative_sign().size();
> _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
> __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
> _M_negative_sign = __negative_sign;
>
> _M_pos_format = __mp.pos_format();
> _M_neg_format = __mp.neg_format();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(money_base::_S_atoms,
> money_base::_S_atoms + money_base::_S_end, _M_atoms);
> }
># 266 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/locale_facets.tcc" 3
> static bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp);
>
> 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 typename numpunct<_CharT>::__cache_type __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;
>
>
> bool __found_mantissa = false;
>
>
> if (__beg != __end)
> {
> const char_type __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 ? '+' : '-';
> ++__beg;
> }
> }
>
>
> while (__beg != __end)
> {
> const char_type __c = *__beg;
> 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;
> }
> ++__beg;
> }
> else
> break;
> }
>
>
> bool __found_dec = false;
> bool __found_sci = false;
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> int __sep_pos = 0;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
> const char_type* __q;
> while (__beg != __end)
> {
>
>
> const char_type __c = *__beg;
> 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;
> ++__beg;
> }
> else
> {
> __err |= ios_base::failbit;
> 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;
> ++__beg;
> }
> else
> break;
> }
> else if ((__q = __traits_type::find(__lit_zero, 10, __c)))
> {
> __xtrc += __num_base::_S_atoms_in[__q - __lit];
> __found_mantissa = true;
> ++__sep_pos;
> ++__beg;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && __found_mantissa && !__found_sci)
> {
>
> if (__found_grouping.size() && !__found_dec)
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> const bool __plus = *__beg == __lit[__num_base::_S_iplus];
> if ((__plus || *__beg == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping
> && *__beg == __lc->_M_thousands_sep)
> && !(*__beg == __lc->_M_decimal_point))
> {
> __xtrc += __plus ? '+' : '-';
> ++__beg;
> }
> }
> }
> else
>
> break;
> }
>
>
>
> if (__lc->_M_use_grouping && __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;
> }
>
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> 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;
> typedef typename numpunct<_CharT>::__cache_type __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;
>
>
> 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 __found_num = false;
>
>
> bool __negative = false;
> if (__beg != __end)
> {
> const char_type __c = *__beg;
> if (numeric_limits<_ValueT>::is_signed)
> __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))
> ++__beg;
> }
>
>
>
> while (__beg != __end)
> {
> const char_type __c = *__beg;
> 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_num || __base == 10))
> {
> __found_num = true;
> ++__beg;
> }
> else if (__found_num)
> {
> if (__c == __lit[__num_base::_S_ix]
> || __c == __lit[__num_base::_S_iX])
> {
> if (__basefield == 0)
> __base = 16;
> if (__base == 16)
> {
> __found_num = false;
> ++__beg;
> }
> }
> else if (__basefield == 0)
> __base = 8;
> break;
> }
> else
> break;
> }
>
>
>
> 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);
> int __sep_pos = 0;
> bool __overflow = false;
> _ValueT __result = 0;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
> const char_type* __q;
> if (__negative)
> {
> const _ValueT __min = numeric_limits<_ValueT>::min() / __base;
> for (; __beg != __end; ++__beg)
> {
>
>
> const char_type __c = *__beg;
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
> __err |= ios_base::failbit;
> break;
> }
> }
> else if (__c == __lc->_M_decimal_point)
> break;
> else if ((__q = __traits_type::find(__lit_zero, __len, __c)))
> {
> int __digit = __q - __lit_zero;
> if (__digit > 15)
> __digit -= 6;
> if (__result < __min)
> __overflow = true;
> else
> {
> const _ValueT __new_result = __result * __base
> - __digit;
> __overflow |= __new_result > __result;
> __result = __new_result;
> ++__sep_pos;
> __found_num = true;
> }
> }
> else
>
> break;
> }
> }
> else
> {
> const _ValueT __max = numeric_limits<_ValueT>::max() / __base;
> for (; __beg != __end; ++__beg)
> {
> const char_type __c = *__beg;
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
> __err |= ios_base::failbit;
> break;
> }
> }
> else if (__c == __lc->_M_decimal_point)
> break;
> else if ((__q = __traits_type::find(__lit_zero, __len, __c)))
> {
> int __digit = __q - __lit_zero;
> if (__digit > 15)
> __digit -= 6;
> if (__result > __max)
> __overflow = true;
> else
> {
> const _ValueT __new_result = __result * __base
> + __digit;
> __overflow |= __new_result < __result;
> __result = __new_result;
> ++__sep_pos;
> __found_num = true;
> }
> }
> else
> break;
> }
> }
>
>
>
> if (__lc->_M_use_grouping && __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 (!(__err & ios_base::failbit) && !__overflow
> && __found_num)
> __v = __result;
> else
> __err |= ios_base::failbit;
>
> 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, 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 = __l;
> else
> __err |= ios_base::failbit;
> }
> else
> {
>
> typedef char_traits<_CharT> __traits_type;
> typedef typename numpunct<_CharT>::__cache_type __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;
> size_t __n;
> for (__n = 0; __beg != __end; ++__n, ++__beg)
> {
> if (__testf)
> if (__n < __lc->_M_falsename_size)
> __testf = *__beg == __lc->_M_falsename[__n];
> else
> break;
>
> if (__testt)
> if (__n < __lc->_M_truename_size)
> __testt = *__beg == __lc->_M_truename[__n];
> else
> break;
>
> if (!__testf && !__testt)
> break;
> }
> if (__testf && __n == __lc->_M_falsename_size)
> __v = 0;
> else if (__testt && __n == __lc->_M_truename_size)
> __v = 1;
> else
> __err |= ios_base::failbit;
>
> 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, long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> 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, unsigned short& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> 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, unsigned int& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> 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, unsigned long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> 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 long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> 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, unsigned long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> 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());
> 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());
> 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, 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());
> 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);
>
> unsigned long __ul;
> __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
>
>
> __io.flags(__fmt);
>
> if (!(__err & ios_base::failbit))
> __v = reinterpret_cast<void*>(__ul);
> else
> __err |= ios_base::failbit;
> 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, true);
> __len = static_cast<int>(__w);
> }
>
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, long __v, const _CharT* __lit,
> ios_base::fmtflags __flags)
> {
> unsigned long __ul = static_cast<unsigned long>(__v);
> bool __neg = false;
> if (__v < 0)
> {
> __ul = -__ul;
> __neg = true;
> }
> return __int_to_char(__bufend, __ul, __lit, __flags, __neg);
> }
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, unsigned long __v, const _CharT* __lit,
> ios_base::fmtflags __flags)
> {
>
> return __int_to_char(__bufend, __v, __lit,
> __flags & ~ios_base::showpos, false);
> }
>
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, long long __v, const _CharT* __lit,
> ios_base::fmtflags __flags)
> {
> unsigned long long __ull = static_cast<unsigned long long>(__v);
> bool __neg = false;
> if (__v < 0)
> {
> __ull = -__ull;
> __neg = true;
> }
> return __int_to_char(__bufend, __ull, __lit, __flags, __neg);
> }
>
> template<typename _CharT>
> inline int
> __int_to_char(_CharT* __bufend, unsigned long long __v,
> const _CharT* __lit, ios_base::fmtflags __flags)
> { return __int_to_char(__bufend, __v, __lit,
> __flags & ~ios_base::showpos, false); }
>
>
> template<typename _CharT, typename _ValueT>
> int
> __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
> ios_base::fmtflags __flags, bool __neg)
> {
>
> const bool __showbase = (__flags & ios_base::showbase) && __v;
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> _CharT* __buf = __bufend - 1;
>
> if (__builtin_expect(__basefield != ios_base::oct &&
> __basefield != ios_base::hex, true))
> {
>
> do
> {
> *__buf-- = __lit[(__v % 10) + __num_base::_S_odigits];
> __v /= 10;
> }
> while (__v != 0);
> if (__neg)
> *__buf-- = __lit[__num_base::_S_ominus];
> else if (__flags & ios_base::showpos)
> *__buf-- = __lit[__num_base::_S_oplus];
> }
> else if (__basefield == ios_base::oct)
> {
>
> do
> {
> *__buf-- = __lit[(__v & 0x7) + __num_base::_S_odigits];
> __v >>= 3;
> }
> while (__v != 0);
> if (__showbase)
> *__buf-- = __lit[__num_base::_S_odigits];
> }
> 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);
> if (__showbase)
> {
>
> *__buf-- = __lit[__num_base::_S_ox + __uppercase];
>
> *__buf-- = __lit[__num_base::_S_odigits];
> }
> }
> return __bufend - __buf - 1;
> }
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
> ios_base& __io, _CharT* __new, _CharT* __cs, int& __len) const
> {
>
>
>
>
>
> streamsize __off = 0;
> const ios_base::fmtflags __basefield = __io.flags()
> & ios_base::basefield;
> if ((__io.flags() & ios_base::showbase) && __len > 1)
> if (__basefield == ios_base::oct)
> {
> __off = 1;
> __new[0] = __cs[0];
> }
> else if (__basefield == ios_base::hex)
> {
> __off = 2;
> __new[0] = __cs[0];
> __new[1] = __cs[1];
> }
> _CharT* __p;
> __p = std::__add_grouping(__new + __off, __sep, __grouping,
> __grouping_size, __cs + __off,
> __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
> {
> typedef typename numpunct<_CharT>::__cache_type __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 int __ilen = 4 * sizeof(_ValueT);
> _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __ilen));
>
>
>
> int __len;
> __len = __int_to_char(__cs + __ilen, __v, __lit, __io.flags());
> __cs += __ilen - __len;
>
>
> if (__lc->_M_use_grouping)
> {
>
>
> _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len * 2));
> _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __io, __cs2, __cs, __len);
> __cs = __cs2;
> }
>
>
> 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
> {
>
>
>
> _CharT* __p2;
> const int __declen = __p ? __p - __cs : __len;
> __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;
> }
># 1041 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 typename numpunct<_CharT>::__cache_type __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
>
> streamsize __prec = __io.precision();
> if (__prec < static_cast<streamsize>(0))
> __prec = static_cast<streamsize>(6);
>
> const int __max_digits = numeric_limits<_ValueT>::digits10;
>
>
> int __len;
>
> char __fbuf[16];
>
>
>
>
> int __cs_size = __max_digits * 3;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
>
> __num_base::_S_format_float(__io, __fbuf, __mod);
> __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
> _S_get_c_locale(), __prec);
>
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
> _S_get_c_locale(), __prec);
> }
># 1105 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
>
>
> const _CharT __cdec = __ctype.widen('.');
> const _CharT __dec = __lc->_M_decimal_point;
> const _CharT* __p;
> if ((__p = char_traits<_CharT>::find(__ws, __len, __cdec)))
> __ws[__p - __ws] = __dec;
>
>
> if (__lc->_M_use_grouping)
> {
>
>
> _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len * 2));
> _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __p, __ws2, __ws, __len);
> __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 typename numpunct<_CharT>::__cache_type __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))
> {
> _CharT* __cs
> = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __cs, __name, __len);
> __name = __cs;
> }
> __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, long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
> { return _M_insert_int(__s, __b, __fill, __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> 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); }
>
> 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
> | ios_base::internal);
> __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
>
> __s = _M_insert_int(__s, __io, __fill,
> reinterpret_cast<unsigned long>(__v));
> __io.flags(__flags);
> return __s;
> }
>
> template<typename _CharT, typename _InIter>
> template<bool _Intl>
> _InIter
> money_get<_CharT, _InIter>::
> _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, string& __units) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef typename string_type::size_type size_type;
> typedef money_base::part part;
> typedef moneypunct<_CharT, _Intl> __moneypunct_type;
> typedef typename __moneypunct_type::__cache_type __cache_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> __use_cache<__cache_type> __uc;
> const __cache_type* __lc = __uc(__loc);
> const char_type* __lit = __lc->_M_atoms;
>
>
> bool __negative = false;
>
> size_type __sign_size = 0;
>
> const bool __mandatory_sign = (__lc->_M_positive_sign_size
> && __lc->_M_negative_sign_size);
>
> string __grouping_tmp;
> if (__lc->_M_use_grouping)
> __grouping_tmp.reserve(32);
>
> int __last_pos = 0;
>
> int __n = 0;
>
> bool __testvalid = true;
>
> bool __testdecfound = false;
>
>
> string __res;
> __res.reserve(32);
>
> const char_type* __lit_zero = __lit + money_base::_S_zero;
> const char_type* __q;
> const money_base::pattern __p = __lc->_M_neg_format;
> for (int __i = 0; __i < 4 && __testvalid; ++__i)
> {
> const part __which = static_cast<part>(__p.field[__i]);
> switch (__which)
> {
> case money_base::symbol:
>
>
>
>
> if (__io.flags() & ios_base::showbase || __sign_size > 1
> || __i == 0
> || (__i == 1 && (__mandatory_sign
> || (static_cast<part>(__p.field[0])
> == money_base::sign)
> || (static_cast<part>(__p.field[2])
> == money_base::space)))
> || (__i == 2 && ((static_cast<part>(__p.field[3])
> == money_base::value)
> || __mandatory_sign
> && (static_cast<part>(__p.field[3])
> == money_base::sign))))
> {
> const size_type __len = __lc->_M_curr_symbol_size;
> size_type __j = 0;
> for (; __beg != __end && __j < __len
> && *__beg == __lc->_M_curr_symbol[__j];
> ++__beg, ++__j);
> if (__j != __len
> && (__j || __io.flags() & ios_base::showbase))
> __testvalid = false;
> }
> break;
> case money_base::sign:
>
> if (__lc->_M_positive_sign_size && __beg != __end
> && *__beg == __lc->_M_positive_sign[0])
> {
> __sign_size = __lc->_M_positive_sign_size;
> ++__beg;
> }
> else if (__lc->_M_negative_sign_size && __beg != __end
> && *__beg == __lc->_M_negative_sign[0])
> {
> __negative = true;
> __sign_size = __lc->_M_negative_sign_size;
> ++__beg;
> }
> else if (__lc->_M_positive_sign_size
> && !__lc->_M_negative_sign_size)
>
>
> __negative = true;
> else if (__mandatory_sign)
> __testvalid = false;
> break;
> case money_base::value:
>
>
> for (; __beg != __end; ++__beg)
> if ((__q = __traits_type::find(__lit_zero, 10, *__beg)))
> {
> __res += money_base::_S_atoms[__q - __lit];
> ++__n;
> }
> else if (*__beg == __lc->_M_decimal_point && !__testdecfound)
> {
> __last_pos = __n;
> __n = 0;
> __testdecfound = true;
> }
> else if (__lc->_M_use_grouping
> && *__beg == __lc->_M_thousands_sep
> && !__testdecfound)
> {
> if (__n)
> {
>
> __grouping_tmp += static_cast<char>(__n);
> __n = 0;
> }
> else
> {
> __testvalid = false;
> break;
> }
> }
> else
> break;
> if (__res.empty())
> __testvalid = false;
> break;
> case money_base::space:
>
> if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
> ++__beg;
> else
> __testvalid = false;
> case money_base::none:
>
> if (__i != 3)
> for (; __beg != __end
> && __ctype.is(ctype_base::space, *__beg); ++__beg);
> break;
> }
> }
>
>
> if (__sign_size > 1 && __testvalid)
> {
> const char_type* __sign = __negative ? __lc->_M_negative_sign
> : __lc->_M_positive_sign;
> size_type __i = 1;
> for (; __beg != __end && __i < __sign_size
> && *__beg == __sign[__i]; ++__beg, ++__i);
>
> if (__i != __sign_size)
> __testvalid = false;
> }
>
> if (__testvalid)
> {
>
> if (__res.size() > 1)
> {
> const size_type __first = __res.find_first_not_of('0');
> const bool __only_zeros = __first == string::npos;
> if (__first)
> __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
> }
>
>
> if (__negative && __res[0] != '0')
> __res.insert(__res.begin(), '-');
>
>
> if (__grouping_tmp.size())
> {
>
> __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
> : __n);
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __grouping_tmp))
> __testvalid = false;
> }
>
>
> if (__testdecfound && __lc->_M_frac_digits > 0
> && __n != __lc->_M_frac_digits)
> __testvalid = false;
> }
>
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
>
>
> if (!__testvalid)
> __err |= ios_base::failbit;
> else
> __units.swap(__res);
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> money_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, long double& __units) const
> {
> string __str;
> if (__intl)
> __beg = _M_extract<true>(__beg, __end, __io, __err, __str);
> else
> __beg = _M_extract<false>(__beg, __end, __io, __err, __str);
> std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> money_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
> ios_base::iostate& __err, string_type& __units) const
> {
> typedef typename string::size_type size_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> string __str;
> const iter_type __ret = __intl ? _M_extract<true>(__beg, __end, __io,
> __err, __str)
> : _M_extract<false>(__beg, __end, __io,
> __err, __str);
> const size_type __len = __str.size();
> if (__len)
> {
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __ctype.widen(__str.data(), __str.data() + __len, __ws);
> __units.assign(__ws, __len);
> }
>
> return __ret;
> }
>
> template<typename _CharT, typename _OutIter>
> template<bool _Intl>
> _OutIter
> money_put<_CharT, _OutIter>::
> _M_insert(iter_type __s, ios_base& __io, char_type __fill,
> const string_type& __digits) const
> {
> typedef typename string_type::size_type size_type;
> typedef money_base::part part;
> typedef moneypunct<_CharT, _Intl> __moneypunct_type;
> typedef typename __moneypunct_type::__cache_type __cache_type;
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> __use_cache<__cache_type> __uc;
> const __cache_type* __lc = __uc(__loc);
> const char_type* __lit = __lc->_M_atoms;
>
>
>
> const char_type* __beg = __digits.data();
>
> money_base::pattern __p;
> const char_type* __sign;
> size_type __sign_size;
> if (*__beg != __lit[money_base::_S_minus])
> {
> __p = __lc->_M_pos_format;
> __sign = __lc->_M_positive_sign;
> __sign_size = __lc->_M_positive_sign_size;
> }
> else
> {
> __p = __lc->_M_neg_format;
> __sign = __lc->_M_negative_sign;
> __sign_size = __lc->_M_negative_sign_size;
> if (__digits.size())
> ++__beg;
> }
>
>
> size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
> __beg + __digits.size()) - __beg;
> if (__len)
> {
>
>
>
> string_type __value;
> __value.reserve(2 * __len);
>
>
>
> int __paddec = __len - __lc->_M_frac_digits;
> if (__paddec > 0)
> {
> if (__lc->_M_frac_digits < 0)
> __paddec = __len;
> if (__lc->_M_grouping_size)
> {
> _CharT* __ws =
> static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * 2 * __len));
> _CharT* __ws_end =
> std::__add_grouping(__ws, __lc->_M_thousands_sep,
> __lc->_M_grouping,
> __lc->_M_grouping_size,
> __beg, __beg + __paddec);
> __value.assign(__ws, __ws_end - __ws);
> }
> else
> __value.assign(__beg, __paddec);
> }
>
>
> if (__lc->_M_frac_digits > 0)
> {
> __value += __lc->_M_decimal_point;
> if (__paddec >= 0)
> __value.append(__beg + __paddec, __lc->_M_frac_digits);
> else
> {
>
> __value.append(-__paddec, __lit[money_base::_S_zero]);
> __value.append(__beg, __len);
> }
> }
>
>
> const ios_base::fmtflags __f = __io.flags()
> & ios_base::adjustfield;
> __len = __value.size() + __sign_size;
> __len += ((__io.flags() & ios_base::showbase)
> ? __lc->_M_curr_symbol_size : 0);
>
> string_type __res;
> __res.reserve(2 * __len);
>
> const size_type __width = static_cast<size_type>(__io.width());
> const bool __testipad = (__f == ios_base::internal
> && __len < __width);
>
> for (int __i = 0; __i < 4; ++__i)
> {
> const part __which = static_cast<part>(__p.field[__i]);
> switch (__which)
> {
> case money_base::symbol:
> if (__io.flags() & ios_base::showbase)
> __res.append(__lc->_M_curr_symbol,
> __lc->_M_curr_symbol_size);
> break;
> case money_base::sign:
>
>
>
> if (__sign_size)
> __res += __sign[0];
> break;
> case money_base::value:
> __res += __value;
> break;
> case money_base::space:
>
>
>
> if (__testipad)
> __res.append(__width - __len, __fill);
> else
> __res += __fill;
> break;
> case money_base::none:
> if (__testipad)
> __res.append(__width - __len, __fill);
> break;
> }
> }
>
>
> if (__sign_size > 1)
> __res.append(__sign + 1, __sign_size - 1);
>
>
> __len = __res.size();
> if (__width > __len)
> {
> if (__f == ios_base::left)
>
> __res.append(__width - __len, __fill);
> else
>
> __res.insert(0, __width - __len, __fill);
> __len = __width;
> }
>
>
> __s = std::__write(__s, __res.data(), __len);
> }
> __io.width(0);
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> money_put<_CharT, _OutIter>::
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> long double __units) const
> {
> const locale __loc = __io.getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>
> int __cs_size = 64;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
>
>
> int __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
> _S_get_c_locale(), 0);
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
> _S_get_c_locale(), 0);
> }
>
>
>
>
>
>
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __cs_size));
> __ctype.widen(__cs, __cs + __len, __ws);
> const string_type __digits(__ws, __len);
> return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
> : _M_insert<false>(__s, __io, __fill, __digits);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> money_put<_CharT, _OutIter>::
> do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
> const string_type& __digits) const
> { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
> : _M_insert<false>(__s, __io, __fill, __digits); }
>
>
>
>
>
> template<typename _CharT, typename _InIter>
> time_base::dateorder
> time_get<_CharT, _InIter>::do_date_order() const
> { return time_base::no_order; }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm,
> const _CharT* __format) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const size_t __len = char_traits<_CharT>::length(__format);
>
> for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
> {
> if (__ctype.narrow(__format[__i], 0) == '%')
> {
>
> char __c = __ctype.narrow(__format[++__i], 0);
> int __mem = 0;
> if (__c == 'E' || __c == 'O')
> __c = __ctype.narrow(__format[++__i], 0);
> switch (__c)
> {
> const char* __cs;
> _CharT __wcs[10];
> case 'a':
>
> const char_type* __days1[7];
> __tp._M_days_abbreviated(__days1);
> __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
> 7, __io, __err);
> break;
> case 'A':
>
> const char_type* __days2[7];
> __tp._M_days(__days2);
> __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
> 7, __io, __err);
> break;
> case 'h':
> case 'b':
>
> const char_type* __months1[12];
> __tp._M_months_abbreviated(__months1);
> __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
> __months1, 12, __io, __err);
> break;
> case 'B':
>
> const char_type* __months2[12];
> __tp._M_months(__months2);
> __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
> __months2, 12, __io, __err);
> break;
> case 'c':
>
> const char_type* __dt[2];
> __tp._M_date_time_formats(__dt);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dt[0]);
> break;
> case 'd':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
> __io, __err);
> break;
> case 'e':
>
>
> if (__ctype.is(ctype_base::space, *__beg))
> __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
> 1, __io, __err);
> else
> __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
> 2, __io, __err);
> break;
> case 'D':
>
> __cs = "%m/%d/%y";
> __ctype.widen(__cs, __cs + 9, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __wcs);
> break;
> case 'H':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
> __io, __err);
> break;
> case 'I':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
> __io, __err);
> break;
> case 'm':
>
> __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
> __io, __err);
> if (!__err)
> __tm->tm_mon = __mem - 1;
> break;
> case 'M':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
> __io, __err);
> break;
> case 'n':
> if (__ctype.narrow(*__beg, 0) == '\n')
> ++__beg;
> else
> __err |= ios_base::failbit;
> break;
> case 'R':
>
> __cs = "%H:%M";
> __ctype.widen(__cs, __cs + 6, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __wcs);
> break;
> case 'S':
>
>
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
>
>
>
> __io, __err);
> break;
> case 't':
> if (__ctype.narrow(*__beg, 0) == '\t')
> ++__beg;
> else
> __err |= ios_base::failbit;
> break;
> case 'T':
>
> __cs = "%H:%M:%S";
> __ctype.widen(__cs, __cs + 9, __wcs);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __wcs);
> break;
> case 'x':
>
> const char_type* __dates[2];
> __tp._M_date_formats(__dates);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dates[0]);
> break;
> case 'X':
>
> const char_type* __times[2];
> __tp._M_time_formats(__times);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __times[0]);
> break;
> case 'y':
> case 'C':
>
> __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
> __io, __err);
> break;
> case 'Y':
>
> __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
> __io, __err);
> if (!__err)
> __tm->tm_year = __mem - 1900;
> break;
> case 'Z':
>
> if (__ctype.is(ctype_base::upper, *__beg))
> {
> int __tmp;
> __beg = _M_extract_name(__beg, __end, __tmp,
> __timepunct_cache<_CharT>::_S_timezones,
> 14, __io, __err);
>
>
> if (__beg != __end && !__err && __tmp == 0
> && (*__beg == __ctype.widen('-')
> || *__beg == __ctype.widen('+')))
> {
> __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
> __io, __err);
> __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
> __io, __err);
> }
> }
> else
> __err |= ios_base::failbit;
> break;
> default:
>
> __err |= ios_base::failbit;
> }
> }
> else
> {
>
> if (__format[__i] == *__beg)
> ++__beg;
> else
> __err |= ios_base::failbit;
> }
> }
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_num(iter_type __beg, iter_type __end, int& __member,
> int __min, int __max, size_t __len,
> ios_base& __io, ios_base::iostate& __err) const
> {
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
>
> int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
>
> ++__min;
> size_t __i = 0;
> int __value = 0;
> for (; __beg != __end && __i < __len; ++__beg, ++__i)
> {
> const char __c = __ctype.narrow(*__beg, '*');
> if (__c >= '0' && __c <= '9')
> {
> __value = __value * 10 + (__c - '0');
> const int __valuec = __value * __mult;
> if (__valuec > __max || __valuec + __mult < __min)
> break;
> __mult /= 10;
> }
> else
> break;
> }
> if (__i == __len)
> __member = __value;
> else
> __err |= ios_base::failbit;
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> _M_extract_name(iter_type __beg, iter_type __end, int& __member,
> const _CharT** __names, size_t __indexlen,
> ios_base& __io, ios_base::iostate& __err) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
> * __indexlen));
> size_t __nmatches = 0;
> size_t __pos = 0;
> bool __testvalid = true;
> const char_type* __name;
>
>
>
>
>
> if (__beg != __end)
> {
> const char_type __c = *__beg;
> for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
> if (__c == __names[__i1][0]
> || __c == __ctype.toupper(__names[__i1][0]))
> __matches[__nmatches++] = __i1;
> }
>
> while (__nmatches > 1)
> {
>
> size_t __minlen = __traits_type::length(__names[__matches[0]]);
> for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
> __minlen = std::min(__minlen,
> __traits_type::length(__names[__matches[__i2]]));
> ++__beg, ++__pos;
> if (__pos < __minlen && __beg != __end)
> for (size_t __i3 = 0; __i3 < __nmatches;)
> {
> __name = __names[__matches[__i3]];
> if (__name[__pos] != *__beg)
> __matches[__i3] = __matches[--__nmatches];
> else
> ++__i3;
> }
> else
> break;
> }
>
> if (__nmatches == 1)
> {
>
> ++__beg, ++__pos;
> __name = __names[__matches[0]];
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
> ++__beg, ++__pos;
>
> if (__len == __pos)
> __member = __matches[0];
> else
> __testvalid = false;
> }
> else
> __testvalid = false;
> if (!__testvalid)
> __err |= ios_base::failbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const char_type* __times[2];
> __tp._M_time_formats(__times);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __times[0]);
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const char_type* __dates[2];
> __tp._M_date_formats(__dates);
> __beg = _M_extract_via_format(__beg, __end, __io, __err,
> __tm, __dates[0]);
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const char_type* __days[7];
> __tp._M_days_abbreviated(__days);
> int __tmpwday;
> __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7, __io, __err);
>
>
>
>
>
>
>
> if (!__err && __beg != __end)
> {
> size_t __pos = __traits_type::length(__days[__tmpwday]);
> __tp._M_days(__days);
> const char_type* __name = __days[__tmpwday];
> if (__name[__pos] == *__beg)
> {
>
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end
> && __name[__pos] == *__beg)
> ++__beg, ++__pos;
> if (__len != __pos)
> __err |= ios_base::failbit;
> }
> }
> if (!__err)
> __tm->tm_wday = __tmpwday;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_monthname(iter_type __beg, iter_type __end,
> ios_base& __io, ios_base::iostate& __err, tm* __tm) const
> {
> typedef char_traits<_CharT> __traits_type;
> const locale& __loc = __io._M_getloc();
> const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
> const char_type* __months[12];
> __tp._M_months_abbreviated(__months);
> int __tmpmon;
> __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
> __io, __err);
>
>
>
>
>
>
>
> if (!__err && __beg != __end)
> {
> size_t __pos = __traits_type::length(__months[__tmpmon]);
> __tp._M_months(__months);
> const char_type* __name = __months[__tmpmon];
> if (__name[__pos] == *__beg)
> {
>
> const size_t __len = __traits_type::length(__name);
> while (__pos < __len && __beg != __end
> && __name[__pos] == *__beg)
> ++__beg, ++__pos;
> if (__len != __pos)
> __err |= ios_base::failbit;
> }
> }
> if (!__err)
> __tm->tm_mon = __tmpmon;
>
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> time_get<_CharT, _InIter>::
> do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, tm* __tm) const
> {
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> size_t __i = 0;
> int __value = 0;
> for (; __beg != __end && __i < 4; ++__beg, ++__i)
> {
> const char __c = __ctype.narrow(*__beg, '*');
> if (__c >= '0' && __c <= '9')
> __value = __value * 10 + (__c - '0');
> else
> break;
> }
> if (__i == 2 || __i == 4)
> __tm->tm_year = __i == 2 ? __value : __value - 1900;
> else
> __err |= ios_base::failbit;
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> time_put<_CharT, _OutIter>::
> put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
> const _CharT* __beg, const _CharT* __end) const
> {
> const locale& __loc = __io._M_getloc();
> ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
> for (; __beg != __end; ++__beg)
> if (__ctype.narrow(*__beg, 0) != '%')
> {
> *__s = *__beg;
> ++__s;
> }
> else if (++__beg != __end)
> {
> char __format;
> char __mod = 0;
> const char __c = __ctype.narrow(*__beg, 0);
> if (__c != 'E' && __c != 'O')
> __format = __c;
> else if (++__beg != __end)
> {
> __mod = __c;
> __format = __ctype.narrow(*__beg, 0);
> }
> else
> break;
> __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
> }
> else
> break;
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> time_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
> char __format, char __mod) const
> {
> const locale& __loc = __io._M_getloc();
> ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
> __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
>
>
>
> const size_t __maxlen = 128;
> char_type* __res =
> static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
>
>
>
>
>
>
> char_type __fmt[4];
> __fmt[0] = __ctype.widen('%');
> if (!__mod)
> {
> __fmt[1] = __format;
> __fmt[2] = char_type();
> }
> else
> {
> __fmt[1] = __mod;
> __fmt[2] = __format;
> __fmt[3] = char_type();
> }
>
> __tp._M_put(__res, __maxlen, __fmt, __tm);
>
>
> return std::__write(__s, __res, char_traits<char_type>::length(__res));
> }
>
>
>
> template<typename _CharT>
> int
> collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
> { return 0; }
>
>
> template<typename _CharT>
> size_t
> collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
> { 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 __str(__lo, __hi);
>
> const _CharT* __p = __str.c_str();
> const _CharT* __pend = __str.data() + __str.length();
>
> size_t __len = (__hi - __lo) * 2;
>
> string_type __ret;
>
>
>
>
> for (;;)
> {
>
> _CharT* __c =
> static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
> size_t __res = _M_transform(__c, __p, __len);
>
>
> if (__res >= __len)
> {
> __len = __res + 1;
> __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __res = _M_transform(__c, __p, __res + 1);
> }
>
> __ret.append(__c, __res);
> __p += char_traits<_CharT>::length(__p);
> if (__p == __pend)
> return __ret;
>
> __p++;
> __ret.push_back(_CharT());
> }
> }
>
> 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 >> (numeric_limits<unsigned long>::digits - 7)));
> return static_cast<long>(__val);
> }
># 2388 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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,
> const streamsize __newlen,
> const streamsize __oldlen, const bool __num)
> {
> 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, const_cast<_CharT*>(__olds), __oldlen);
> _Traits::assign(__news + __oldlen, __plen, __fill);
> return;
> }
>
> size_t __mod = 0;
> if (__adjust == ios_base::internal && __num)
> {
>
>
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> const bool __testsign = (__ctype.widen('-') == __olds[0]
> || __ctype.widen('+') == __olds[0]);
> const bool __testhex = (__ctype.widen('0') == __olds[0]
> && __oldlen > 1
> && (__ctype.widen('x') == __olds[1]
> || __ctype.widen('X') == __olds[1]));
> if (__testhex)
> {
> __news[0] = __olds[0];
> __news[1] = __olds[1];
> __mod = 2;
> __news += 2;
> }
> else if (__testsign)
> {
> __news[0] = __olds[0];
> __mod = 1;
> ++__news;
> }
>
> }
> _Traits::assign(__news, __plen, __fill);
> _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
> __oldlen - __mod);
> }
>
> bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp)
> {
> const size_t __n = __grouping_tmp.size() - 1;
> const size_t __min = std::min(__n, __grouping_size - 1);
> size_t __i = __n;
> bool __test = true;
>
>
>
>
> for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
> __test = __grouping_tmp[__i] == __grouping[__j];
> for (; __i && __test; --__i)
> __test = __grouping_tmp[__i] == __grouping[__min];
>
>
> __test &= __grouping_tmp[0] <= __grouping[__min];
> return __test;
> }
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last)
> {
> if (__last - __first > *__gbeg)
> {
> const bool __bump = __gsize != 1;
> __s = std::__add_grouping(__s, __sep, __gbeg + __bump,
> __gsize - __bump, __first,
> __last - *__gbeg);
> __first = __last - *__gbeg;
> *__s++ = __sep;
> }
> do
> *__s++ = *__first++;
> while (__first != __last);
> return __s;
> }
>
>
>
>
>
> extern template class moneypunct<char, false>;
> extern template class moneypunct<char, true>;
> extern template class moneypunct_byname<char, false>;
> extern template class moneypunct_byname<char, true>;
> extern template class money_get<char>;
> extern template class money_put<char>;
> 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 __timepunct<char>;
> extern template class time_put<char>;
> extern template class time_put_byname<char>;
> extern template class time_get<char>;
> extern template class time_get_byname<char>;
> extern template class messages<char>;
> extern template class messages_byname<char>;
> extern template class ctype_byname<char>;
> extern template class codecvt_byname<char, char, mbstate_t>;
> extern template class collate<char>;
> extern template class collate_byname<char>;
>
> extern template
> const codecvt<char, char, mbstate_t>&
> use_facet<codecvt<char, char, mbstate_t> >(const locale&);
>
> extern template
> const collate<char>&
> use_facet<collate<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
> const moneypunct<char, true>&
> use_facet<moneypunct<char, true> >(const locale&);
>
> extern template
> const moneypunct<char, false>&
> use_facet<moneypunct<char, false> >(const locale&);
>
> extern template
> const money_put<char>&
> use_facet<money_put<char> >(const locale&);
>
> extern template
> const money_get<char>&
> use_facet<money_get<char> >(const locale&);
>
> extern template
> const __timepunct<char>&
> use_facet<__timepunct<char> >(const locale&);
>
> extern template
> const time_put<char>&
> use_facet<time_put<char> >(const locale&);
>
> extern template
> const time_get<char>&
> use_facet<time_get<char> >(const locale&);
>
> extern template
> const messages<char>&
> use_facet<messages<char> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<char> >(const locale&);
>
> extern template
> bool
> has_facet<codecvt<char, char, mbstate_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<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
> bool
> has_facet<moneypunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<money_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<money_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<__timepunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<time_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<time_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<messages<char> >(const locale&);
>
>
> extern template class moneypunct<wchar_t, false>;
> extern template class moneypunct<wchar_t, true>;
> extern template class moneypunct_byname<wchar_t, false>;
> extern template class moneypunct_byname<wchar_t, true>;
> extern template class money_get<wchar_t>;
> extern template class money_put<wchar_t>;
> 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 __timepunct<wchar_t>;
> extern template class time_put<wchar_t>;
> extern template class time_put_byname<wchar_t>;
> extern template class time_get<wchar_t>;
> extern template class time_get_byname<wchar_t>;
> extern template class messages<wchar_t>;
> extern template class messages_byname<wchar_t>;
> extern template class ctype_byname<wchar_t>;
> extern template class codecvt_byname<wchar_t, char, mbstate_t>;
> extern template class collate<wchar_t>;
> extern template class collate_byname<wchar_t>;
>
> extern template
> const codecvt<wchar_t, char, mbstate_t>&
> use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
>
> extern template
> const collate<wchar_t>&
> use_facet<collate<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
> const moneypunct<wchar_t, true>&
> use_facet<moneypunct<wchar_t, true> >(const locale&);
>
> extern template
> const moneypunct<wchar_t, false>&
> use_facet<moneypunct<wchar_t, false> >(const locale&);
>
> extern template
> const money_put<wchar_t>&
> use_facet<money_put<wchar_t> >(const locale&);
>
> extern template
> const money_get<wchar_t>&
> use_facet<money_get<wchar_t> >(const locale&);
>
> extern template
> const __timepunct<wchar_t>&
> use_facet<__timepunct<wchar_t> >(const locale&);
>
> extern template
> const time_put<wchar_t>&
> use_facet<time_put<wchar_t> >(const locale&);
>
> extern template
> const time_get<wchar_t>&
> use_facet<time_get<wchar_t> >(const locale&);
>
> extern template
> const messages<wchar_t>&
> use_facet<messages<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<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&);
>
> extern template
> bool
> has_facet<moneypunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<money_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<money_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<__timepunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<time_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<time_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<messages<wchar_t> >(const locale&);
>
>
>}
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/locale" 2 3
># 41 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/istream.tcc" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 1 3
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> 
># 44 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
>
>
>
>namespace std
>{
># 57 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>
> template<typename _CharT2, typename _Traits2>
> friend basic_ostream<_CharT2, _Traits2>&
> operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);
>
> template<typename _Traits2>
> friend basic_ostream<char, _Traits2>&
> operator<<(basic_ostream<char, _Traits2>&, char);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_ostream<_CharT2, _Traits2>&
> operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);
>
> template<typename _Traits2>
> friend basic_ostream<char, _Traits2>&
> operator<<(basic_ostream<char, _Traits2>&, const char*);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_ostream<_CharT2, _Traits2>&
> operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);
># 104 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> explicit
> basic_ostream(__streambuf_type* __sb)
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_ostream() { }
>
>
> class sentry;
> friend class sentry;
># 130 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> inline __ostream_type&
> operator<<(__ostream_type& (*__pf)(__ostream_type&));
>
> inline __ostream_type&
> operator<<(__ios_type& (*__pf)(__ios_type&));
>
> inline __ostream_type&
> operator<<(ios_base& (*__pf) (ios_base&));
># 167 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> operator<<(long __n);
>
> __ostream_type&
> operator<<(unsigned long __n);
>
> __ostream_type&
> operator<<(bool __n);
>
> __ostream_type&
> operator<<(short __n)
> {
> ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt & ios_base::oct || __fmt & ios_base::hex)
> return this->operator<<(static_cast<unsigned long>
> (static_cast<unsigned short>(__n)));
> else
> return this->operator<<(static_cast<long>(__n));
> }
>
> __ostream_type&
> operator<<(unsigned short __n)
> { return this->operator<<(static_cast<unsigned long>(__n)); }
>
> __ostream_type&
> operator<<(int __n)
> {
> ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt & ios_base::oct || __fmt & ios_base::hex)
> return this->operator<<(static_cast<unsigned long>
> (static_cast<unsigned int>(__n)));
> else
> return this->operator<<(static_cast<long>(__n));
> }
>
> __ostream_type&
> operator<<(unsigned int __n)
> { return this->operator<<(static_cast<unsigned long>(__n)); }
>
>
> __ostream_type&
> operator<<(long long __n);
>
> __ostream_type&
> operator<<(unsigned long long __n);
>
>
> __ostream_type&
> operator<<(double __f);
>
> __ostream_type&
> operator<<(float __f)
> { return this->operator<<(static_cast<double>(__f)); }
>
> __ostream_type&
> operator<<(long double __f);
>
> __ostream_type&
> operator<<(const void* __p);
># 248 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> operator<<(__streambuf_type* __sb);
># 281 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> put(char_type __c);
>
>
> void
> _M_write(const char_type* __s, streamsize __n)
> {
> streamsize __put = this->rdbuf()->sputn(__s, __n);
> if (__put != __n)
> this->setstate(ios_base::badbit);
> }
># 309 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> write(const char_type* __s, streamsize __n);
># 322 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> flush();
># 333 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> pos_type
> tellp();
># 344 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> seekp(pos_type);
># 356 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> __ostream_type&
> seekp(off_type, ios_base::seekdir);
>
> protected:
> explicit
> basic_ostream() { }
> };
># 374 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> template <typename _CharT, typename _Traits>
> class basic_ostream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
> basic_ostream<_CharT,_Traits>& _M_os;
>
> public:
># 393 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> explicit
> sentry(basic_ostream<_CharT,_Traits>& __os);
># 403 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> ~sentry()
> {
>
> if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
> {
>
> if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
> _M_os.setstate(ios_base::badbit);
> }
> }
># 421 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> operator bool() const
> { return _M_ok; }
> };
># 442 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
> { return (__out << __out.widen(__c)); }
>
>
> template <class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c);
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
> { return (__out << static_cast<char>(__c)); }
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
> { return (__out << static_cast<char>(__c)); }
># 482 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits> &
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const char* __s);
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
>
> template<class _Traits>
> basic_ostream<char, _Traits> &
> operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
># 516 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 3
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> endl(basic_ostream<_CharT, _Traits>& __os)
> { return flush(__os.put(__os.widen('\n'))); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> ends(basic_ostream<_CharT, _Traits>& __os)
> { return __os.put(_CharT()); }
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> flush(basic_ostream<_CharT, _Traits>& __os)
> { return __os.flush(); }
>
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ostream.tcc" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ostream.tcc" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/ostream.tcc" 3
>
>
>
>namespace std
>{
> 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>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__ostream_type& (*__pf)(__ostream_type&))
> {
>
>
>
> return __pf(*this);
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__ios_type& (*__pf)(__ios_type&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(ios_base& (*__pf)(ios_base&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(bool __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> 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<<(long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> bool __b = false;
> const char_type __c = this->fill();
> const ios_base::fmtflags __fmt = (this->flags()
> & ios_base::basefield);
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
> {
> const unsigned long __l = static_cast<unsigned long>(__n);
> __b = __np.put(*this, *this, __c, __l).failed();
> }
> else
> __b = __np.put(*this, *this, __c, __n).failed();
> if (__b)
> __err |= ios_base::badbit;
> }
> 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<<(unsigned long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> 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<<(long long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> bool __b = false;
> const char_type __c = this->fill();
> const ios_base::fmtflags __fmt = (this->flags()
> & ios_base::basefield);
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
> {
> const unsigned long long __l = (static_cast<
> unsigned long long>(__n));
> __b = __np.put(*this, *this, __c, __l).failed();
> }
> else
> __b = __np.put(*this, *this, __c, __n).failed();
> if (__b)
> __err |= ios_base::badbit;
> }
> 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<<(unsigned long long __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> 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<<(double __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> 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<<(long double __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> 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<<(const void* __n)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __n).failed())
> __err |= ios_base::badbit;
> }
> 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<<(__streambuf_type* __sbin)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> sentry __cerb(*this);
> if (__cerb && __sbin)
> {
> try
> {
> if (!__copy_streambufs(__sbin, this->rdbuf()))
> __err |= ios_base::failbit;
> }
> 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::iostate(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 (...)
> { 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 (...)
> { 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::iostate(ios_base::goodbit);
> try
> {
> if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
> __err |= ios_base::badbit;
> }
> 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(...)
> { 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::iostate(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(...)
> { 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::iostate(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(...)
> { 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, _CharT __c)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = 1;
> _CharT* __cs = &__c;
> if (__w > __len)
> {
> __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
> &__c, __w, __len, false);
> __len = __w;
> }
> __out._M_write(__cs, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> return __out;
> }
>
>
> template <class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c)
> {
> typedef basic_ostream<char, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = 1;
> char* __cs = &__c;
> if (__w > __len)
> {
> __cs = static_cast<char*>(__builtin_alloca(__w));
> __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
> &__c, __w, __len, false);
> __len = __w;
> }
> __out._M_write(__cs, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb && __s)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(_Traits::length(__s));
> if (__w > __len)
> {
> _CharT* __cs = (static_cast<
> _CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w)));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
> __s, __w, __len, false);
> __s = __cs;
> __len = __w;
> }
> __out._M_write(__s, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> else if (!__s)
> __out.setstate(ios_base::badbit);
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
> typedef char_traits<char> __traits_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb && __s)
> {
> size_t __clen = __traits_type::length(__s);
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __clen));
> for (size_t __i = 0; __i < __clen; ++__i)
> __ws[__i] = __out.widen(__s[__i]);
> _CharT* __str = __ws;
>
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(__clen);
> if (__w > __len)
> {
> _CharT* __cs = (static_cast<
> _CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w)));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
> __ws, __w, __len, false);
> __str = __cs;
> __len = __w;
> }
> __out._M_write(__str, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> else if (!__s)
> __out.setstate(ios_base::badbit);
> return __out;
> }
>
>
> template<class _Traits>
> basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
> {
> typedef basic_ostream<char, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb && __s)
> {
> try
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(_Traits::length(__s));
> if (__w > __len)
> {
> char* __cs = static_cast<char*>(__builtin_alloca(__w));
> __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
> __s, __w, __len, false);
> __s = __cs;
> __len = __w;
> }
> __out._M_write(__s, __len);
> __out.width(0);
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> else if (!__s)
> __out.setstate(ios_base::badbit);
> return __out;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out,
> const basic_string<_CharT, _Traits, _Alloc>& __str)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> const streamsize __w = __out.width();
> streamsize __len = static_cast<streamsize>(__str.size());
> const _CharT* __s = __str.data();
>
>
>
> if (__w > __len)
> {
> _CharT* __cs = (static_cast<
> _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
> __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
> __w, __len, false);
> __s = __cs;
> __len = __w;
> }
> __out._M_write(__s, __len);
> __out.width(0);
> }
> 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 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*);
>
>
>}
># 546 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/ostream" 2 3
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/istream.tcc" 2 3
>
>namespace std
>{
> 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::iostate(ios_base::goodbit);
> if (__in.good())
> {
> if (__in.tie())
> __in.tie()->flush();
> if (!__noskip && (__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;
> }
> }
>
> if (__in.good() && __err == ios_base::goodbit)
> _M_ok = true;
> else
> {
> __err |= ios_base::failbit;
> __in.setstate(__err);
> }
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__istream_type& (*__pf)(__istream_type&))
> { return __pf(*this); }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__ios_type& (*__pf)(__ios_type&))
> {
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(ios_base& (*__pf)(ios_base&))
> {
> __pf(*this);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(bool& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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::iostate(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 (!(__err & ios_base::failbit)
> && (numeric_limits<short>::min() <= __l
> && __l <= numeric_limits<short>::max()))
> __n = __l;
> else
> __err |= ios_base::failbit;
> }
> 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>>(unsigned short& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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::iostate(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 (!(__err & ios_base::failbit)
> && (numeric_limits<int>::min() <= __l
> && __l <= numeric_limits<int>::max()))
> __n = __l;
> else
> __err |= ios_base::failbit;
> }
> 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>>(unsigned int& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(unsigned long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(long long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(unsigned long long& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(float& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(double& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(long double& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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>>(void*& __n)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __n);
> }
> 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::iostate(ios_base::goodbit);
> sentry __cerb(*this, false);
> if (__cerb && __sbout)
> {
> try
> {
> if (!__copy_streambufs(this->rdbuf(), __sbout))
> __err |= ios_base::failbit;
> }
> 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::iostate(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(...)
> { 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::iostate(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(...)
> { 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::iostate(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(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> *__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::iostate(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(...)
> { 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::iostate(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))
> {
> streamsize __size = std::min(streamsize(__sb->egptr()
> - __sb->gptr()),
> __n - _M_gcount - 1);
> if (__size > 1)
> {
> const char_type* __p = traits_type::find(__sb->gptr(),
> __size,
> __delim);
> if (__p)
> __size = __p - __sb->gptr();
> traits_type::copy(__s, __sb->gptr(), __size);
> __s += __size;
> __sb->gbump(__size);
> _M_gcount += __size;
> __c = __sb->sgetc();
> }
> else
> {
> *__s++ = traits_type::to_char_type(__c);
> ++_M_gcount;
> __c = __sb->snextc();
> }
> }
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else if (traits_type::eq_int_type(__c, __idelim))
> {
> ++_M_gcount;
> __sb->sbumpc();
> }
> else
> __err |= ios_base::failbit;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> *__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(streamsize __n, int_type __delim)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c;
>
> if (__n != numeric_limits<streamsize>::max())
> --__n;
> while (_M_gcount <= __n
> && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
> {
> ++_M_gcount;
> if (traits_type::eq_int_type(__c, __delim))
> break;
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> 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::iostate(ios_base::goodbit);
> try
> {
> __c = this->rdbuf()->sgetc();
> if (traits_type::eq_int_type(__c, traits_type::eof()))
> __err |= ios_base::eofbit;
> }
> 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::iostate(ios_base::goodbit);
> try
> {
> _M_gcount = this->rdbuf()->sgetn(__s, __n);
> if (_M_gcount != __n)
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> 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::iostate(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(...)
> { 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;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(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(...)
> { 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;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::iostate(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(...)
> { 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::iostate(ios_base::goodbit);
> try
> {
> __streambuf_type* __sb = this->rdbuf();
> if (__sb)
> {
> if (__sb->pubsync() == -1)
> __err |= ios_base::badbit;
> else
> __ret = 0;
> }
> }
> 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);
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
> }
> 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)
> {
>
>
> ios_base::iostate __err = ios_base::iostate(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(...)
> { 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)
> {
>
>
> ios_base::iostate __err = ios_base::iostate(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(...)
> { 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::iostate(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(...)
> { __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 typename __istream_type::__streambuf_type __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::iostate(ios_base::goodbit);
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> streamsize __num = __in.width();
> if (__num <= 0)
> __num = numeric_limits<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(...)
> { __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 typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef typename __istream_type::int_type __int_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;
> }
>
>
> 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 typename __istream_type::int_type __int_type;
> typedef typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> ios_base::iostate __err = ios_base::iostate(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();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->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 = __sb->snextc();
> }
> __str.append(__buf, __len);
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> __in.width(0);
> }
> 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 typename __istream_type::int_type __int_type;
> typedef typename __istream_type::__streambuf_type __streambuf_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> const __size_type __n = __str.max_size();
> ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
> typename __istream_type::sentry __cerb(__in, true);
> if (__cerb)
> {
> try
> {
>
> __str.erase();
> _CharT __buf[128];
> __size_type __len = 0;
> const __int_type __idelim = _Traits::to_int_type(__delim);
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !_Traits::eq_int_type(__c, __idelim))
> {
> if (__len == sizeof(__buf) / sizeof(_CharT))
> {
> __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
> __len = 0;
> }
> __buf[__len++] = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
> __str.append(__buf, __len);
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else if (_Traits::eq_int_type(__c, __idelim))
> {
> ++__extracted;
> __sb->sbumpc();
> }
> else
> __err |= ios_base::failbit;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(ios_base::badbit);
> }
> }
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
> template<class _CharT, class _Traits, class _Alloc>
> inline basic_istream<_CharT,_Traits>&
> getline(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT,_Traits,_Alloc>& __str)
> { return getline(__in, __str, __in.widen('\n')); }
>
>
>
>
>
> 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 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 class basic_iostream<wchar_t>;
>
>
>}
># 772 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/istream" 2 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 2 3
>
>
>namespace std
>{
># 62 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
>
>
>
>
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
> typedef basic_string<char_type, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
>
> protected:
>
>
>
>
>
> ios_base::openmode _M_mode;
>
>
>
>
>
>
>
> __string_type _M_string;
>
> public:
># 112 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(__mode), _M_string()
> { }
># 125 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_stringbuf(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
> { _M_stringbuf_init(__mode); }
># 140 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> __string_type
> str() const
> {
> if (this->pptr())
> {
>
> if (this->pptr() > this->egptr())
> return __string_type(this->pbase(), this->pptr());
> else
> return __string_type(this->pbase(), this->egptr());
> }
> else
> return _M_string;
> }
># 162 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> void
> str(const __string_type& __s)
> {
>
> _M_string.assign(__s.data(), __s.size());
> _M_stringbuf_init(this->_M_mode);
> }
>
> protected:
>
>
>
>
>
>
> void
> _M_stringbuf_init(ios_base::openmode __mode)
> {
> this->_M_mode = __mode;
>
> __size_type __len = 0;
> if (this->_M_mode & (ios_base::ate | ios_base::app))
> __len = _M_string.size();
> _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
> }
>
> virtual streamsize
> showmanyc()
> {
> streamsize __ret = -1;
> if (_M_mode & ios_base::in)
> {
> _M_update_egptr();
> __ret = this->egptr() - this->gptr();
> }
> return __ret;
> }
>
>
> virtual int_type
> underflow();
>
>
> virtual int_type
> pbackfail(int_type __c = traits_type::eof());
>
>
> virtual int_type
> overflow(int_type __c = traits_type::eof());
># 223 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> virtual __streambuf_type*
> setbuf(char_type* __s, streamsize __n)
> {
> if (__s && __n >= 0)
> {
>
>
>
>
>
>
> _M_string = __string_type(__s, __n);
>
>
> _M_sync(__s, 0, 0);
> }
> return this;
> }
>
>
> virtual pos_type
> seekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
>
> virtual pos_type
> seekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
># 263 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> void
> _M_sync(char_type* __base, __size_type __i, __size_type __o)
> {
> const bool __testin = this->_M_mode & ios_base::in;
> const bool __testout = this->_M_mode & ios_base::out;
> const __size_type __len = _M_string.size();
>
> if (__testin)
> this->setg(__base, __base + __i, __base + __len);
> if (__testout)
> {
> this->setp(__base, __base + _M_string.capacity());
> this->pbump(__o);
>
>
>
>
> if (!__testin)
> this->setg(__base + __len, __base + __len, __base + __len);
> }
> }
>
>
>
> void
> _M_update_egptr()
> {
> const bool __testin = this->_M_mode & ios_base::in;
>
> if (this->pptr() && this->pptr() > this->egptr())
> if (__testin)
> this->setg(this->eback(), this->gptr(), this->pptr());
> else
> this->setg(this->pptr(), this->pptr(), this->pptr());
> }
> };
># 310 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_istringstream : public basic_istream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_istream<char_type, traits_type> __istream_type;
>
> private:
>
>
>
>
>
> __stringbuf_type _M_stringbuf;
>
> public:
># 353 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_istringstream(ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__mode | ios_base::in)
> { this->init(&_M_stringbuf); }
># 373 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_istringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_istringstream()
> { }
># 395 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 428 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> template <typename _CharT, typename _Traits, typename _Alloc>
> class basic_ostringstream : public basic_ostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_ostream<char_type, traits_type> __ostream_type;
>
> private:
>
>
>
>
>
> __stringbuf_type _M_stringbuf;
>
> public:
># 471 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_ostringstream(ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
> { this->init(&_M_stringbuf); }
># 491 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_ostringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_ostringstream()
> { }
># 513 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 546 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> template <typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringstream : public basic_iostream<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
> typedef basic_iostream<char_type, traits_type> __iostream_type;
>
> private:
>
>
>
>
>
> __stringbuf_type _M_stringbuf;
>
> public:
># 587 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__m)
> { this->init(&_M_stringbuf); }
># 605 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> explicit
> basic_stringstream(const __string_type& __str,
> ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__str, __m)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_stringstream()
> { }
># 627 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
>}
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/sstream.tcc" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/sstream.tcc" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/sstream.tcc" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 1 3
># 41 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/sstream.tcc" 2 3
>
>namespace std
>{
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> pbackfail(int_type __c)
> {
> int_type __ret = traits_type::eof();
> const bool __testeof = traits_type::eq_int_type(__c, __ret);
>
> if (this->eback() < this->gptr())
> {
> const bool __testeq = traits_type::eq(traits_type::to_char_type(__c),
> this->gptr()[-1]);
> this->gbump(-1);
>
>
>
> if (!__testeof && __testeq)
> __ret = __c;
> else if (__testeof)
> __ret = traits_type::not_eof(__c);
> else
> {
> *this->gptr() = traits_type::to_char_type(__c);
> __ret = __c;
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> overflow(int_type __c)
> {
> const bool __testout = this->_M_mode & ios_base::out;
> if (__builtin_expect(!__testout, false))
> return traits_type::eof();
>
> const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
> if (__builtin_expect(__testeof, false))
> return traits_type::not_eof(__c);
>
> const __size_type __capacity = _M_string.capacity();
> const __size_type __max_size = _M_string.max_size();
> const bool __testput = this->pptr() < this->epptr();
> if (__builtin_expect(!__testput && __capacity == __max_size, false))
> return traits_type::eof();
>
>
>
> if (!__testput)
> {
>
>
>
>
>
>
> const __size_type __opt_len = std::max(__size_type(2 * __capacity),
> __size_type(512));
> const __size_type __len = std::min(__opt_len, __max_size);
> __string_type __tmp;
> __tmp.reserve(__len);
> __tmp.assign(_M_string.data(), this->epptr() - this->pbase());
> _M_string.swap(__tmp);
> _M_sync(const_cast<char_type*>(_M_string.data()),
> this->gptr() - this->eback(), this->pptr() - this->pbase());
> }
> return this->sputc(traits_type::to_char_type(__c));
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> underflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testin = this->_M_mode & ios_base::in;
> if (__testin)
> {
>
> _M_update_egptr();
>
> if (this->gptr() < this->egptr())
> __ret = traits_type::to_int_type(*this->gptr());
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
> {
> pos_type __ret = pos_type(off_type(-1));
> bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
> bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
> const bool __testboth = __testin && __testout && __way != ios_base::cur;
> __testin &= !(__mode & ios_base::out);
> __testout &= !(__mode & ios_base::in);
>
>
>
> const char_type* __beg = __testin ? this->eback() : this->pbase();
> if ((__beg || !__off) && (__testin || __testout || __testboth))
> {
> _M_update_egptr();
>
> off_type __newoffi = 0;
> off_type __newoffo = 0;
> if (__way == ios_base::cur)
> {
> __newoffi = this->gptr() - __beg;
> __newoffo = this->pptr() - __beg;
> }
> else if (__way == ios_base::end)
> __newoffo = __newoffi = this->egptr() - __beg;
>
> if ((__testin || __testboth)
> && __newoffi + __off >= 0
> && this->egptr() - __beg >= __newoffi + __off)
> {
> this->gbump((__beg + __newoffi + __off) - this->gptr());
> __ret = pos_type(__newoffi);
> }
> if ((__testout || __testboth)
> && __newoffo + __off >= 0
> && this->egptr() - __beg >= __newoffo + __off)
> {
> this->pbump((__beg + __newoffo + __off) - this->pptr());
> __ret = pos_type(__newoffo);
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> seekpos(pos_type __sp, ios_base::openmode __mode)
> {
> pos_type __ret = pos_type(off_type(-1));
> const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
> const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
>
> const char_type* __beg = __testin ? this->eback() : this->pbase();
> if (__beg)
> {
> _M_update_egptr();
>
> off_type __pos(__sp);
> const bool __testpos = 0 <= __pos
> && __pos <= this->egptr() - __beg;
> if ((__testin || __testout) && __testpos)
> {
> if (__testin)
> this->gbump((__beg + __pos) - this->gptr());
> if (__testout)
> this->pbump((__beg + __pos) - this->pptr());
> __ret = __sp;
> }
> }
> return __ret;
> }
>
>
>
>
>
> extern template class basic_stringbuf<char>;
> extern template class basic_istringstream<char>;
> extern template class basic_ostringstream<char>;
> extern template class basic_stringstream<char>;
>
>
> extern template class basic_stringbuf<wchar_t>;
> extern template class basic_istringstream<wchar_t>;
> extern template class basic_ostringstream<wchar_t>;
> extern template class basic_stringstream<wchar_t>;
>
>
>}
># 653 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/sstream" 2 3
># 37 "aiLex.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 2 3
># 38 "aiLex.h" 2
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 3
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 3
>namespace std
>{
>
> void
> __throw_bad_exception(void);
>
>
> void
> __throw_bad_alloc(void);
>
>
> void
> __throw_bad_cast(void);
>
> void
> __throw_bad_typeid(void);
>
>
> void
> __throw_logic_error(const char* __s);
>
> void
> __throw_domain_error(const char* __s);
>
> void
> __throw_invalid_argument(const char* __s);
>
> void
> __throw_length_error(const char* __s);
>
> void
> __throw_out_of_range(const char* __s);
>
> void
> __throw_runtime_error(const char* __s);
>
> void
> __throw_range_error(const char* __s);
>
> void
> __throw_overflow_error(const char* __s);
>
> void
> __throw_underflow_error(const char* __s);
>
>
> void
> __throw_ios_failure(const char* __s);
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 2 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 1 3
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 3
>namespace std
>{
>
> void
> __throw_bad_exception(void);
>
>
> void
> __throw_bad_alloc(void);
>
>
> void
> __throw_bad_cast(void);
>
> void
> __throw_bad_typeid(void);
>
>
> void
> __throw_logic_error(const char* __s);
>
> void
> __throw_domain_error(const char* __s);
>
> void
> __throw_invalid_argument(const char* __s);
>
> void
> __throw_length_error(const char* __s);
>
> void
> __throw_out_of_range(const char* __s);
>
> void
> __throw_runtime_error(const char* __s);
>
> void
> __throw_range_error(const char* __s);
>
> void
> __throw_overflow_error(const char* __s);
>
> void
> __throw_underflow_error(const char* __s);
>
>
> void
> __throw_ios_failure(const char* __s);
>}
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 2 3
>
>
>namespace std
>{
>
>
>
>
>
> template<typename _Tp, typename _Alloc>
> struct _Vector_base
> {
> struct _Vector_impl
> : public _Alloc {
> _Tp* _M_start;
> _Tp* _M_finish;
> _Tp* _M_end_of_storage;
> _Vector_impl (_Alloc const& __a)
> : _Alloc(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const { return *static_cast<const _Alloc*>(&this->_M_impl); }
>
> _Vector_base(const allocator_type& __a) : _M_impl(__a)
> { }
>
> _Vector_base(size_t __n, const allocator_type& __a)
> : _M_impl(__a)
> {
> 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;
> }
>
> ~_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;
>
> _Tp*
> _M_allocate(size_t __n) { return _M_impl.allocate(__n); }
>
> void
> _M_deallocate(_Tp* __p, size_t __n)
> { if (__p) _M_impl.deallocate(__p, __n); }
> };
># 140 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc = allocator<_Tp> >
> class vector : protected _Vector_base<_Tp, _Alloc>
> {
>
> 
>
> typedef _Vector_base<_Tp, _Alloc> _Base;
> typedef vector<_Tp, _Alloc> vector_type;
>
> public:
> typedef _Tp value_type;
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::const_reference const_reference;
> typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type>
> 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 typename _Base::allocator_type allocator_type;
>
> protected:
>
>
>
>
>
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_M_impl;
>
> public:
>
>
>
>
>
> explicit
> vector(const allocator_type& __a = allocator_type())
> : _Base(__a) { }
># 191 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> vector(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> { this->_M_impl._M_finish = std::uninitialized_fill_n(this->_M_impl._M_start,
> __n, __value); }
># 204 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> explicit
> vector(size_type __n)
> : _Base(__n, allocator_type())
> { this->_M_impl._M_finish = std::uninitialized_fill_n(this->_M_impl._M_start,
> __n, value_type()); }
># 219 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> vector(const vector& __x)
> : _Base(__x.size(), __x.get_allocator())
> { this->_M_impl._M_finish = std::uninitialized_copy(__x.begin(), __x.end(),
> this->_M_impl._M_start);
> }
># 240 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> template<typename _InputIterator>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
>
>
>
>
>
>
> ~vector() { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish); }
># 266 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> vector&
> operator=(const vector& __x);
># 279 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 295 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> 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()); }
>
>
>
> size_type
> size() const { return size_type(end() - begin()); }
>
>
> size_type
> max_size() const { return size_type(-1) / sizeof(value_type); }
># 392 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> void
> resize(size_type __new_size, const value_type& __x)
> {
> if (__new_size < size())
> erase(begin() + __new_size, end());
> else
> insert(end(), __new_size - size(), __x);
> }
># 411 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> void
> resize(size_type __new_size) { resize(__new_size, value_type()); }
>
>
>
>
>
> size_type
> capacity() const
> { return size_type(const_iterator(this->_M_impl._M_end_of_storage) - begin()); }
>
>
>
>
>
> bool
> empty() const { return begin() == end(); }
># 446 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> void
> reserve(size_type __n);
># 461 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> reference
> operator[](size_type __n) { return *(begin() + __n); }
># 475 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> const_reference
> operator[](size_type __n) const { return *(begin() + __n); }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector::_M_range_check"));
> }
>
> public:
># 499 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> reference
> at(size_type __n) { _M_range_check(__n); return (*this)[__n]; }
># 513 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 555 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)
> {
> std::_Construct(this->_M_impl._M_finish, __x);
> ++this->_M_impl._M_finish;
> }
> else
> _M_insert_aux(end(), __x);
> }
># 576 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> void
> pop_back()
> {
> --this->_M_impl._M_finish;
> std::_Destroy(this->_M_impl._M_finish);
> }
># 594 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 610 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 628 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 653 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> iterator
> erase(iterator __position);
># 674 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 686 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_vector.h" 3
> 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);
> }
>
>
>
>
>
>
>
> void
> clear() { erase(begin(), end()); }
>
> 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(__first, __last, __result);
> return __result;
> }
> catch(...)
> {
> _M_deallocate(__result, __n);
> throw;
> }
> }
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
> {
> this->_M_impl._M_start = _M_allocate(__n);
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> this->_M_impl._M_finish = std::uninitialized_fill_n(this->_M_impl._M_start,
> __n, __value);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename iterator_traits<_InputIterator>::iterator_category
> _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first,
> _InputIterator __last, input_iterator_tag)
> {
> for ( ; __first != __last; ++__first)
> push_back(*__first);
> }
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first,
> _ForwardIterator __last, forward_iterator_tag)
> {
> 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(__first, __last,
> this->_M_impl._M_start);
> }
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> {
> _M_fill_assign(static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename iterator_traits<_InputIterator>::iterator_category
> _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> forward_iterator_tag);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
> __true_type)
> {
> _M_fill_insert(__pos, static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos, _InputIterator __first,
> _InputIterator __last, __false_type)
> {
> typedef typename 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, input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, forward_iterator_tag);
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
> void
> _M_insert_aux(iterator __position, const value_type& __x);
> };
># 874 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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());
> }
># 893 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
>}
># 72 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_bvector.h" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_bvector.h" 3
>namespace std
>{
> 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; }
> };
>
> struct _Bit_iterator_base : public iterator<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++ == _S_word_bit - 1)
> {
> _M_offset = 0;
> ++_M_p;
> }
> }
>
> void
> _M_bump_down()
> {
> if (_M_offset-- == 0)
> {
> _M_offset = _S_word_bit - 1;
> --_M_p;
> }
> }
>
> void
> _M_incr(ptrdiff_t __i)
> {
> difference_type __n = __i + _M_offset;
> _M_p += __n / _S_word_bit;
> __n = __n % _S_word_bit;
> if (__n < 0)
> {
> _M_offset = static_cast<unsigned int>(__n + _S_word_bit);
> --_M_p;
> }
> else
> _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 _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)
> { 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)
> { return *(*this + __i); }
> };
>
> inline _Bit_const_iterator
> operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
> { return __x + __n; }
>
> template<class _Alloc>
> class _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(const _Bit_alloc_type& __a)
> : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
> { }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
>
> _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }
>
> ~_Bvector_base() { this->_M_deallocate(); }
>
> protected:
> _Bvector_impl _M_impl;
>
> _Bit_type*
> _M_allocate(size_t __n)
> { return _M_impl.allocate((__n + _S_word_bit - 1) / _S_word_bit); }
>
> 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);
> }
> };
>}
>
>
>
>
>namespace std
>{
># 414 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_bvector.h" 3
>template<typename _Alloc>
> class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
> {
> 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 typename _Bvector_base<_Alloc>::allocator_type allocator_type;
>
> allocator_type get_allocator() const
> { return _Bvector_base<_Alloc>::get_allocator(); }
>
> protected:
> using _Bvector_base<_Alloc>::_M_allocate;
> using _Bvector_base<_Alloc>::_M_deallocate;
>
> protected:
> void _M_initialize(size_type __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = __q
> + (__n + _S_word_bit - 1) / _S_word_bit;
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
> }
>
> void _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 = size() ? 2 * size()
> : static_cast<size_type>(_S_word_bit);
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = std::copy(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 + (__len + _S_word_bit - 1)
> / _S_word_bit;
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
> template<class _InputIterator>
> void _M_initialize_range(_InputIterator __first, _InputIterator __last,
> input_iterator_tag)
> {
> this->_M_impl._M_start = iterator();
> this->_M_impl._M_finish = iterator();
> this->_M_impl._M_end_of_storage = 0;
> for ( ; __first != __last; ++__first)
> push_back(*__first);
> }
>
> template<class _ForwardIterator>
> void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
> forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> _M_initialize(__n);
> std::copy(__first, __last, this->_M_impl._M_start);
> }
>
> template<class _InputIterator>
> void _M_insert_range(iterator __pos, _InputIterator __first,
> _InputIterator __last, input_iterator_tag)
> {
> for ( ; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<class _ForwardIterator>
> void _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, 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 = size() + std::max(size(), __n);
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = std::copy(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 + (__len + _S_word_bit - 1)
> / _S_word_bit;
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
> }
>
> public:
> 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()); }
>
> size_type size() const
> { return size_type(end() - begin()); }
>
> size_type max_size() const
> { return size_type(-1); }
>
> 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 *(begin() + difference_type(__n)); }
>
> const_reference operator[](size_type __n) const
> { return *(begin() + difference_type(__n)); }
>
> void _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector<bool>::_M_range_check"));
> }
>
> 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]; }
>
> explicit vector(const allocator_type& __a = allocator_type())
> : _Bvector_base<_Alloc>(__a) { }
>
> vector(size_type __n, bool __value,
> const allocator_type& __a = allocator_type())
> : _Bvector_base<_Alloc>(__a)
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
> __value ? ~0 : 0);
> }
>
> explicit vector(size_type __n)
> : _Bvector_base<_Alloc>(allocator_type())
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, 0);
> }
>
> vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator())
> {
> _M_initialize(__x.size());
> std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
> }
>
>
> template<class _Integer>
> void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
>
> template<class _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_initialize_range(__first, __last,
> std::__iterator_category(__first)); }
>
> template<class _InputIterator>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Bvector_base<_Alloc>(__a)
> {
> typedef typename _Is_integer<_InputIterator>::_Integral _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());
> }
> std::copy(__x.begin(), __x.end(), begin());
> this->_M_impl._M_finish = begin() + difference_type(__x.size());
> return *this;
> }
>
>
>
>
>
>
> 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
> {
> erase(begin() + __n, end());
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
> }
>
> void assign(size_t __n, bool __x)
> { _M_fill_assign(__n, __x); }
>
> template<class _InputIterator>
> void assign(_InputIterator __first, _InputIterator __last)
> {
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
> template<class _Integer>
> void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign((size_t) __n, (bool) __val); }
>
> template<class _InputIterator>
> void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
>
> template<class _InputIterator>
> void _M_assign_aux(_InputIterator __first, _InputIterator __last,
> input_iterator_tag)
> {
> iterator __cur = begin();
> for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> erase(__cur, end());
> else
> insert(end(), __first, __last);
> }
>
> template<class _ForwardIterator>
> void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len < size())
> erase(std::copy(__first, __last, begin()), end());
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> }
>
> void reserve(size_type __n)
> {
> if (__n > this->max_size())
> __throw_length_error(("vector::reserve"));
> if (this->capacity() < __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_finish = std::copy(begin(), end(),
> iterator(__q, 0));
> this->_M_deallocate();
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
> }
> }
>
> reference front()
> { return *begin(); }
>
> const_reference front() const
> { return *begin(); }
>
> reference back()
> { return *(end() - 1); }
>
> const_reference back() const
> { return *(end() - 1); }
>
> 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<bool, _Alloc>& __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);
> }
>
>
> static void swap(reference __x, reference __y)
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> iterator insert(iterator __position, 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;
> }
>
>
>
> template<class _Integer>
> void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> { _M_fill_insert(__pos, __n, __x); }
>
> template<class _InputIterator>
> void _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_insert_range(__pos, __first, __last,
> std::__iterator_category(__first)); }
>
> template<class _InputIterator>
> void insert(iterator __position,
> _InputIterator __first, _InputIterator __last)
> {
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
>
> void _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 = size() + std::max(size(), __n);
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = std::copy(begin(), __position, iterator(__q, 0));
> std::fill_n(__i, __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 + (__len + _S_word_bit - 1)
> / _S_word_bit;
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
> void insert(iterator __position, size_type __n, 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)
> {
> this->_M_impl._M_finish = std::copy(__last, end(), __first);
> return __first;
> }
>
> void resize(size_type __new_size, bool __x = bool())
> {
> if (__new_size < size())
> erase(begin() + difference_type(__new_size), end());
> 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()
> { erase(begin(), end()); }
> };
>}
># 73 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/vector.tcc" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/vector.tcc" 3
>namespace std
>{
> 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_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;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp,_Alloc>::iterator
> vector<_Tp,_Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage && __position == end())
> {
> std::_Construct(this->_M_impl._M_finish, __x);
> ++this->_M_impl._M_finish;
> }
> else
> _M_insert_aux(__position, __x);
> return begin() + __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;
> std::_Destroy(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)
> {
> iterator __i(std::copy(__last, end(), __first));
> std::_Destroy(__i, end());
> this->_M_impl._M_finish = this->_M_impl._M_finish - (__last - __first);
> return __first;
> }
>
> template<typename _Tp, typename _Alloc>
> vector<_Tp,_Alloc>&
> vector<_Tp,_Alloc>::
> operator=(const vector<_Tp,_Alloc>& __x)
> {
> if (&__x != this)
> {
> 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_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)
> {
> iterator __i(std::copy(__x.begin(), __x.end(), begin()));
> std::_Destroy(__i, end());
> }
> else
> {
> std::copy(__x.begin(), __x.begin() + size(), this->_M_impl._M_start);
> std::uninitialized_copy(__x.begin() + size(), __x.end(), this->_M_impl._M_finish);
> }
> 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, get_allocator());
> __tmp.swap(*this);
> }
> else if (__n > size())
> {
> std::fill(begin(), end(), __val);
> this->_M_impl._M_finish
> = std::uninitialized_fill_n(this->_M_impl._M_finish, __n - size(), __val);
> }
> else
> erase(fill_n(begin(), __n, __val), end());
> }
>
> template<typename _Tp, typename _Alloc> template<typename _InputIterator>
> void
> vector<_Tp,_Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last, input_iterator_tag)
> {
> iterator __cur(begin());
> for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> erase(__cur, end());
> else
> insert(end(), __first, __last);
> }
>
> template<typename _Tp, typename _Alloc> template<typename _ForwardIterator>
> void
> vector<_Tp,_Alloc>::
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> forward_iterator_tag)
> {
> 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_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_finish = this->_M_impl._M_start + __len;
> }
> else if (size() >= __len)
> {
> iterator __new_finish(std::copy(__first, __last, this->_M_impl._M_start));
> std::_Destroy(__new_finish, end());
> this->_M_impl._M_finish = __new_finish.base();
> }
> 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(__mid, __last, this->_M_impl._M_finish);
> }
> }
>
> 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)
> {
> std::_Construct(this->_M_impl._M_finish, *(this->_M_impl._M_finish - 1));
> ++this->_M_impl._M_finish;
> _Tp __x_copy = __x;
> std::copy_backward(__position,
> iterator(this->_M_impl._M_finish-2),
> iterator(this->_M_impl._M_finish-1));
> *__position = __x_copy;
> }
> else
> {
> const size_type __old_size = size();
> const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
> iterator __new_start(this->_M_allocate(__len));
> iterator __new_finish(__new_start);
> try
> {
> __new_finish = std::uninitialized_copy(iterator(this->_M_impl._M_start),
> __position,
> __new_start);
> std::_Construct(__new_finish.base(), __x);
> ++__new_finish;
> __new_finish = std::uninitialized_copy(__position,
> iterator(this->_M_impl._M_finish),
> __new_finish);
> }
> catch(...)
> {
> std::_Destroy(__new_start,__new_finish);
> _M_deallocate(__new_start.base(),__len);
> throw;
> }
> std::_Destroy(begin(), end());
> _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.base();
> this->_M_impl._M_finish = __new_finish.base();
> this->_M_impl._M_end_of_storage = __new_start.base() + __len;
> }
> }
>
> 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;
> iterator __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::uninitialized_copy(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish);
> this->_M_impl._M_finish += __n;
> std::copy_backward(__position, __old_finish - __n, __old_finish);
> std::fill(__position, __position + __n, __x_copy);
> }
> else
> {
> std::uninitialized_fill_n(this->_M_impl._M_finish,
> __n - __elems_after,
> __x_copy);
> this->_M_impl._M_finish += __n - __elems_after;
> std::uninitialized_copy(__position, __old_finish, this->_M_impl._M_finish);
> this->_M_impl._M_finish += __elems_after;
> std::fill(__position, __old_finish, __x_copy);
> }
> }
> else
> {
> const size_type __old_size = size();
> const size_type __len = __old_size + std::max(__old_size, __n);
> iterator __new_start(this->_M_allocate(__len));
> iterator __new_finish(__new_start);
> try
> {
> __new_finish = std::uninitialized_copy(begin(), __position,
> __new_start);
> __new_finish = std::uninitialized_fill_n(__new_finish, __n, __x);
> __new_finish = std::uninitialized_copy(__position, end(),
> __new_finish);
> }
> catch(...)
> {
> std::_Destroy(__new_start,__new_finish);
> _M_deallocate(__new_start.base(),__len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
> _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.base();
> this->_M_impl._M_finish = __new_finish.base();
> this->_M_impl._M_end_of_storage = __new_start.base() + __len;
> }
> }
> }
>
> template<typename _Tp, typename _Alloc> template<typename _InputIterator>
> void
> vector<_Tp,_Alloc>::
> _M_range_insert(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> 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, forward_iterator_tag)
> {
> if (__first != __last)
> {
> 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;
> iterator __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::uninitialized_copy(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish);
> this->_M_impl._M_finish += __n;
> std::copy_backward(__position, __old_finish - __n, __old_finish);
> std::copy(__first, __last, __position);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elems_after);
> std::uninitialized_copy(__mid, __last, this->_M_impl._M_finish);
> this->_M_impl._M_finish += __n - __elems_after;
> std::uninitialized_copy(__position, __old_finish, this->_M_impl._M_finish);
> this->_M_impl._M_finish += __elems_after;
> std::copy(__first, __mid, __position);
> }
> }
> else
> {
> const size_type __old_size = size();
> const size_type __len = __old_size + std::max(__old_size, __n);
> iterator __new_start(this->_M_allocate(__len));
> iterator __new_finish(__new_start);
> try
> {
> __new_finish = std::uninitialized_copy(iterator(this->_M_impl._M_start),
> __position, __new_start);
> __new_finish = std::uninitialized_copy(__first, __last,
> __new_finish);
> __new_finish = std::uninitialized_copy(__position,
> iterator(this->_M_impl._M_finish),
> __new_finish);
> }
> catch(...)
> {
> std::_Destroy(__new_start,__new_finish);
> _M_deallocate(__new_start.base(), __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
> _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.base();
> this->_M_impl._M_finish = __new_finish.base();
> this->_M_impl._M_end_of_storage = __new_start.base() + __len;
> }
> }
> }
>}
># 76 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/vector" 2 3
># 40 "aiLex.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/list" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/list" 3
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/list" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 3
>namespace std
>{
>
> void
> __throw_bad_exception(void);
>
>
> void
> __throw_bad_alloc(void);
>
>
> void
> __throw_bad_cast(void);
>
> void
> __throw_bad_typeid(void);
>
>
> void
> __throw_logic_error(const char* __s);
>
> void
> __throw_domain_error(const char* __s);
>
> void
> __throw_invalid_argument(const char* __s);
>
> void
> __throw_length_error(const char* __s);
>
> void
> __throw_out_of_range(const char* __s);
>
> void
> __throw_runtime_error(const char* __s);
>
> void
> __throw_range_error(const char* __s);
>
> void
> __throw_overflow_error(const char* __s);
>
> void
> __throw_underflow_error(const char* __s);
>
>
> void
> __throw_ios_failure(const char* __s);
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/list" 2 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
>namespace std
>{
>
>
>
>
>
>
> 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);
>
> void
> transfer(_List_node_base * const __first,
> _List_node_base * const __last);
>
> void
> reverse();
>
> void
> hook(_List_node_base * const __position);
>
> void
> unhook();
> };
>
>
> template<typename _Tp>
> struct _List_node : public _List_node_base
> {
> _Tp _M_data;
> };
># 110 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _Tp>
> struct _List_iterator
> {
> typedef _List_iterator<_Tp> _Self;
> typedef _List_node<_Tp> _Node;
>
> typedef ptrdiff_t difference_type;
> typedef bidirectional_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef _Tp* pointer;
> typedef _Tp& reference;
>
> _List_iterator()
> : _M_node() { }
>
> _List_iterator(_List_node_base* __x)
> : _M_node(__x) { }
>
>
> reference
> operator*() const
> { return static_cast<_Node*>(_M_node)->_M_data; }
>
> pointer
> operator->() const
> { return &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; }
>
>
> _List_node_base* _M_node;
> };
># 186 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> 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 bidirectional_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
>
> _List_const_iterator()
> : _M_node() { }
>
> _List_const_iterator(const _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 &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 _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:
># 295 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
>
> _Node_Alloc_type;
>
> struct _List_impl
> : public _Node_Alloc_type {
> _List_node_base _M_node;
> _List_impl (const _Node_Alloc_type& __a)
> : _Node_Alloc_type(__a)
> { }
> };
>
> _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;
>
> allocator_type
> get_allocator() const
> { return allocator_type(*static_cast<const _Node_Alloc_type*>(&this->_M_impl)); }
>
> _List_base(const allocator_type& __a)
> : _M_impl(__a)
> { _M_init(); }
>
>
> ~_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;
> }
> };
># 388 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc = allocator<_Tp> >
> class list : protected _List_base<_Tp, _Alloc>
> {
>
> 
>
> typedef _List_base<_Tp, _Alloc> _Base;
>
> public:
> typedef _Tp value_type;
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::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 typename _Base::allocator_type allocator_type;
>
> protected:
>
>
> typedef _List_node<_Tp> _Node;
>
>
>
>
>
>
>
> using _Base::_M_impl;
> using _Base::_M_put_node;
> using _Base::_M_get_node;
># 432 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> _Node*
> _M_create_node(const value_type& __x)
> {
> _Node* __p = this->_M_get_node();
> try
> {
> std::_Construct(&__p->_M_data, __x);
> }
> catch(...)
> {
> _M_put_node(__p);
> throw;
> }
> return __p;
> }
>
>
>
>
>
>
>
> _Node*
> _M_create_node()
> {
> _Node* __p = this->_M_get_node();
> try
> {
> std::_Construct(&__p->_M_data);
> }
> catch(...)
> {
> _M_put_node(__p);
> throw;
> }
> return __p;
> }
>
> public:
>
>
>
>
>
> explicit
> list(const allocator_type& __a = allocator_type())
> : _Base(__a) { }
># 487 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> list(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { this->insert(begin(), __n, __value); }
># 499 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> explicit
> list(size_type __n)
> : _Base(allocator_type())
> { this->insert(begin(), __n, value_type()); }
># 511 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> list(const list& __x)
> : _Base(__x.get_allocator())
> { this->insert(begin(), __x.begin(), __x.end()); }
># 529 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _InputIterator>
> list(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { this->insert(begin(), __first, __last); }
># 550 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> list&
> operator=(const list& __x);
># 563 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 579 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> allocator_type
> get_allocator() const
> { return _Base::get_allocator(); }
>
>
>
>
>
>
> iterator
> begin()
> { return this->_M_impl._M_node._M_next; }
>
>
>
>
>
>
> const_iterator
> begin() const
> { return this->_M_impl._M_node._M_next; }
>
>
>
>
>
>
> iterator
> end() { return &this->_M_impl._M_node; }
>
>
>
>
>
>
> const_iterator
> end() const
> { return &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()); }
>
>
>
>
>
>
> 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 size_type(-1); }
># 693 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> resize(size_type __new_size, const value_type& __x);
># 705 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> resize(size_type __new_size)
> { this->resize(__new_size, value_type()); }
>
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> { return *(--end()); }
>
>
>
>
>
> const_reference
> back() const
> { return *(--end()); }
># 753 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> push_front(const value_type& __x)
> { this->_M_insert(begin(), __x); }
># 769 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> pop_front()
> { this->_M_erase(begin()); }
># 783 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> push_back(const value_type& __x)
> { this->_M_insert(end(), __x); }
># 798 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> pop_back()
> { this->_M_erase(this->_M_impl._M_node._M_prev); }
># 813 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 829 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 847 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 872 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> iterator
> erase(iterator __position);
># 894 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> iterator
> erase(iterator __first, iterator __last)
> {
> while (__first != __last)
> __first = erase(__first);
> return __last;
> }
># 911 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> swap(list& __x)
> { _List_node_base::swap(this->_M_impl._M_node,__x._M_impl._M_node); }
>
>
>
>
>
>
>
> void
> clear()
> {
> _Base::_M_clear();
> _Base::_M_init();
> }
># 938 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> splice(iterator __position, list& __x)
> {
> if (!__x.empty())
> this->_M_transfer(__position, __x.begin(), __x.end());
> }
># 954 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> splice(iterator __position, list&, iterator __i)
> {
> iterator __j = __i;
> ++__j;
> if (__position == __i || __position == __j)
> return;
> this->_M_transfer(__position, __i, __j);
> }
># 976 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> splice(iterator __position, list&, iterator __first, iterator __last)
> {
> if (__first != __last)
> this->_M_transfer(__position, __first, __last);
> }
># 994 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> remove(const _Tp& __value);
># 1008 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _Predicate>
> void
> remove_if(_Predicate);
># 1022 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> unique();
># 1037 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _BinaryPredicate>
> void
> unique(_BinaryPredicate);
># 1050 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> void
> merge(list& __x);
># 1065 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_list.h" 3
> template<typename _StrictWeakOrdering>
> void
> merge(list&, _StrictWeakOrdering);
>
>
>
>
>
>
> void
> reverse()
> { this->_M_impl._M_node.reverse(); }
>
>
>
>
>
>
>
> void
> sort();
>
>
>
>
>
>
>
> template<typename _StrictWeakOrdering>
> void
> sort(_StrictWeakOrdering);
>
> protected:
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> {
> _M_fill_assign(static_cast<size_type>(__n),
> static_cast<value_type>(__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);
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> {
> _M_fill_insert(__pos, static_cast<size_type>(__n),
> static_cast<value_type>(__x));
> }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> {
> for ( ; __first != __last; ++__first)
> _M_insert(__pos, *__first);
> }
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
> {
> for ( ; __n > 0; --__n)
> _M_insert(__pos, __x);
> }
>
>
>
> void
> _M_transfer(iterator __position, iterator __first, iterator __last)
> { __position._M_node->transfer(__first._M_node,__last._M_node); }
>
>
> void
> _M_insert(iterator __position, const value_type& __x)
> {
> _Node* __tmp = _M_create_node(__x);
> __tmp->hook(__position._M_node);
> }
>
>
> void
> _M_erase(iterator __position)
> {
> __position._M_node->unhook();
> _Node* __n = static_cast<_Node*>(__position._M_node);
> std::_Destroy(&__n->_M_data);
> _M_put_node(__n);
> }
> };
># 1188 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 1217 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
>}
># 72 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/list" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/list.tcc" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/list.tcc" 3
>namespace std
>{
> template<typename _Tp, typename _Alloc>
> void
> _List_base<_Tp,_Alloc>::
> _M_clear()
> {
> typedef _List_node<_Tp> _Node;
> _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next);
> while (__cur != &this->_M_impl._M_node)
> {
> _Node* __tmp = __cur;
> __cur = static_cast<_Node*>(__cur->_M_next);
> std::_Destroy(&__tmp->_M_data);
> _M_put_node(__tmp);
> }
> }
>
> 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->hook(__position._M_node);
> return __tmp;
> }
>
> template<typename _Tp, typename _Alloc>
> typename list<_Tp,_Alloc>::iterator
> list<_Tp,_Alloc>::
> erase(iterator __position)
> {
> iterator __ret = __position._M_node->_M_next;
> _M_erase(__position);
> return __ret;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp,_Alloc>::
> resize(size_type __new_size, const 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();
> while (__first1 != __last1 && __first2 != __last2)
> *__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();
> while (__first != __last)
> {
> iterator __next = __first;
> ++__next;
> if (*__first == __value)
> _M_erase(__first);
> __first = __next;
> }
> }
>
> 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)
> {
> 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>
> 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>::
> merge(list& __x, _StrictWeakOrdering __comp)
> {
>
>
> if (this != &__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>
> 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) );
> }
> }
>}
># 75 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/list" 2 3
># 41 "aiLex.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/deque" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/deque" 3
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/deque" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 1 3
># 36 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/functexcept.h" 3
>namespace std
>{
>
> void
> __throw_bad_exception(void);
>
>
> void
> __throw_bad_alloc(void);
>
>
> void
> __throw_bad_cast(void);
>
> void
> __throw_bad_typeid(void);
>
>
> void
> __throw_logic_error(const char* __s);
>
> void
> __throw_domain_error(const char* __s);
>
> void
> __throw_invalid_argument(const char* __s);
>
> void
> __throw_length_error(const char* __s);
>
> void
> __throw_out_of_range(const char* __s);
>
> void
> __throw_runtime_error(const char* __s);
>
> void
> __throw_range_error(const char* __s);
>
> void
> __throw_overflow_error(const char* __s);
>
> void
> __throw_underflow_error(const char* __s);
>
>
> void
> __throw_ios_failure(const char* __s);
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/deque" 2 3
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 1 3
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
>namespace std
>{
># 82 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> inline size_t
> __deque_buf_size(size_t __size)
> { return __size < 512 ? size_t(512 / __size) : size_t(1); }
># 99 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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 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 _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; }
># 352 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> class _Deque_base
> {
> public:
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return *static_cast<const _Alloc*>(&this->_M_impl); }
>
> typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator;
> typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
>
> _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)
> { }
>
> ~_Deque_base();
>
> protected:
>
>
>
> struct _Deque_impl
> : public _Alloc {
> _Tp** _M_map;
> size_t _M_map_size;
> iterator _M_start;
> iterator _M_finish;
>
> _Deque_impl(const _Alloc& __a)
> : _Alloc(__a), _M_map(0), _M_map_size(0), _M_start(), _M_finish()
> { }
> };
>
> typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
> _Map_alloc_type _M_get_map_allocator() const
> { return _Map_alloc_type(this->get_allocator()); }
>
> _Tp*
> _M_allocate_node()
> { return _M_impl._Alloc::allocate(__deque_buf_size(sizeof(_Tp))); }
>
> void
> _M_deallocate_node(_Tp* __p)
> { _M_impl._Alloc::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);
> }
> }
># 440 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> void
> _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements)
> {
> 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,
> __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);
> }
># 584 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc = allocator<_Tp> >
> class deque : protected _Deque_base<_Tp, _Alloc>
> {
>
> 
>
> typedef _Deque_base<_Tp, _Alloc> _Base;
>
> public:
> typedef _Tp value_type;
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::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 typename _Base::allocator_type 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_impl;
>
> public:
>
>
>
>
>
> explicit
> deque(const allocator_type& __a = allocator_type())
> : _Base(__a, 0) {}
># 645 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> deque(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__a, __n)
> { _M_fill_initialize(__value); }
># 657 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> explicit
> deque(size_type __n)
> : _Base(allocator_type(), __n)
> { _M_fill_initialize(value_type()); }
># 669 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> deque(const deque& __x)
> : _Base(__x.get_allocator(), __x.size())
> { std::uninitialized_copy(__x.begin(), __x.end(), this->_M_impl._M_start); }
># 687 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _InputIterator>
> deque(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
>
>
>
>
>
> ~deque()
> { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish); }
># 712 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> deque&
> operator=(const deque& __x);
># 725 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 741 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> 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); }
>
>
>
> size_type
> size() const
> { return this->_M_impl._M_finish - this->_M_impl._M_start; }
>
>
> size_type
> max_size() const
> { return size_type(-1); }
># 842 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> void
> resize(size_type __new_size, const value_type& __x)
> {
> const size_type __len = size();
> if (__new_size < __len)
> erase(this->_M_impl._M_start + __new_size, this->_M_impl._M_finish);
> else
> insert(this->_M_impl._M_finish, __new_size - __len, __x);
> }
># 861 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> void
> resize(size_type new_size)
> { resize(new_size, value_type()); }
>
>
>
>
> bool
> empty() const
> { return this->_M_impl._M_finish == this->_M_impl._M_start; }
># 882 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> reference
> operator[](size_type __n)
> { return this->_M_impl._M_start[difference_type(__n)]; }
># 895 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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:
># 919 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> reference
> at(size_type __n)
> { _M_range_check(__n); return (*this)[__n]; }
># 933 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front()
> { return *this->_M_impl._M_start; }
>
>
>
>
>
> const_reference
> front() const
> { return *this->_M_impl._M_start; }
>
>
>
>
>
> reference
> back()
> {
> iterator __tmp = this->_M_impl._M_finish;
> --__tmp;
> return *__tmp;
> }
>
>
>
>
>
> const_reference
> back() const
> {
> const_iterator __tmp = this->_M_impl._M_finish;
> --__tmp;
> return *__tmp;
> }
># 989 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)
> {
> std::_Construct(this->_M_impl._M_start._M_cur - 1, __x);
> --this->_M_impl._M_start._M_cur;
> }
> else
> _M_push_front_aux(__x);
> }
># 1009 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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)
> {
> std::_Construct(this->_M_impl._M_finish._M_cur, __x);
> ++this->_M_impl._M_finish._M_cur;
> }
> else
> _M_push_back_aux(__x);
> }
># 1029 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> void
> pop_front()
> {
> if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_last - 1)
> {
> std::_Destroy(this->_M_impl._M_start._M_cur);
> ++this->_M_impl._M_start._M_cur;
> }
> else
> _M_pop_front_aux();
> }
># 1049 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> std::_Destroy(this->_M_impl._M_finish._M_cur);
> }
> else
> _M_pop_back_aux();
> }
># 1070 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> iterator
> insert(iterator position, const value_type& __x);
># 1082 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 1096 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 1119 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> iterator
> erase(iterator __position);
># 1138 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 1150 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
> }
>
>
>
>
>
>
>
> void clear();
>
> protected:
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize_map(__n);
> _M_fill_initialize(__x);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename iterator_traits<_InputIterator>::iterator_category
> _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
># 1204 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first, _InputIterator __last,
> input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
> forward_iterator_tag);
># 1228 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> void
> _M_fill_initialize(const value_type& __value);
>
>
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> {
> _M_fill_assign(static_cast<size_type>(__n),
> static_cast<value_type>(__val));
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename iterator_traits<_InputIterator>::iterator_category
> _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> 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
> erase(std::copy(__first, __last, begin()), end());
> }
>
>
>
> 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
> {
> erase(begin() + __n, end());
> std::fill(begin(), end(), __val);
> }
> }
>
>
>
>
>
>
>
> void _M_push_back_aux(const value_type&);
> void _M_push_front_aux(const value_type&);
> void _M_pop_back_aux();
> void _M_pop_front_aux();
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos,
> _Integer __n, _Integer __x, __true_type)
> {
> _M_fill_insert(__pos, static_cast<size_type>(__n),
> static_cast<value_type>(__x));
> }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename 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, input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, 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);
># 1372 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
># 1410 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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);
>
> };
># 1441 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 1459 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_deque.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const deque<_Tp, _Alloc>& __x,
> const deque<_Tp, _Alloc>& __y)
> { return 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); }
>}
># 72 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/deque" 2 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/deque.tcc" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/deque.tcc" 3
>namespace std
>{
> 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())
> erase(std::copy(__x.begin(), __x.end(), this->_M_impl._M_start),
> this->_M_impl._M_finish);
> 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;
> }
>
> 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);
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp,_Alloc>::iterator
> deque<_Tp,_Alloc>::
> erase(iterator __position)
> {
> iterator __next = __position;
> ++__next;
> size_type __index = __position - this->_M_impl._M_start;
> if (__index < (size() >> 1))
> {
> std::copy_backward(this->_M_impl._M_start, __position, __next);
> pop_front();
> }
> else
> {
> std::copy(__next, this->_M_impl._M_finish, __position);
> pop_back();
> }
> return this->_M_impl._M_start + __index;
> }
>
> template <typename _Tp, typename _Alloc>
> typename deque<_Tp,_Alloc>::iterator
> deque<_Tp,_Alloc>::
> erase(iterator __first, iterator __last)
> {
> if (__first == this->_M_impl._M_start && __last == this->_M_impl._M_finish)
> {
> clear();
> return this->_M_impl._M_finish;
> }
> else
> {
> const difference_type __n = __last - __first;
> const difference_type __elems_before = __first - this->_M_impl._M_start;
> if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
> {
> std::copy_backward(this->_M_impl._M_start, __first, __last);
> iterator __new_start = this->_M_impl._M_start + __n;
> std::_Destroy(this->_M_impl._M_start, __new_start);
> _M_destroy_nodes(this->_M_impl._M_start._M_node, __new_start._M_node);
> this->_M_impl._M_start = __new_start;
> }
> else
> {
> std::copy(__last, this->_M_impl._M_finish, __first);
> iterator __new_finish = this->_M_impl._M_finish - __n;
> std::_Destroy(__new_finish, this->_M_impl._M_finish);
> _M_destroy_nodes(__new_finish._M_node + 1,
> this->_M_impl._M_finish._M_node + 1);
> this->_M_impl._M_finish = __new_finish;
> }
> return this->_M_impl._M_start + __elems_before;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp,_Alloc>::
> clear()
> {
> for (_Map_pointer __node = this->_M_impl._M_start._M_node + 1;
> __node < this->_M_impl._M_finish._M_node;
> ++__node)
> {
> std::_Destroy(*__node, *__node + _S_buffer_size());
> _M_deallocate_node(*__node);
> }
>
> if (this->_M_impl._M_start._M_node != this->_M_impl._M_finish._M_node)
> {
> std::_Destroy(this->_M_impl._M_start._M_cur, this->_M_impl._M_start._M_last);
> std::_Destroy(this->_M_impl._M_finish._M_first, this->_M_impl._M_finish._M_cur);
> _M_deallocate_node(this->_M_impl._M_finish._M_first);
> }
> else
> std::_Destroy(this->_M_impl._M_start._M_cur, this->_M_impl._M_finish._M_cur);
>
> this->_M_impl._M_finish = this->_M_impl._M_start;
> }
>
> template <typename _Tp, class _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp,_Alloc>
> ::_M_assign_aux(_InputIterator __first, _InputIterator __last,
> input_iterator_tag)
> {
> iterator __cur = begin();
> for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> erase(__cur, end());
> 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(__new_start, this->_M_impl._M_start, __x);
> 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(this->_M_impl._M_finish, __new_finish, __x);
> 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);
> }
>
> 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(*__cur, *__cur + _S_buffer_size(), __value);
> std::uninitialized_fill(this->_M_impl._M_finish._M_first,
> this->_M_impl._M_finish._M_cur,
> __value);
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur));
> throw;
> }
> }
>
> template <typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> void
> deque<_Tp,_Alloc>::
> _M_range_initialize(_InputIterator __first, _InputIterator __last,
> 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,
> 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(__first, __mid, *__cur_node);
> __first = __mid;
> }
> std::uninitialized_copy(__first, __last, this->_M_impl._M_finish._M_first);
> }
> catch(...)
> {
> std::_Destroy(this->_M_impl._M_start, iterator(*__cur_node, __cur_node));
> throw;
> }
> }
>
>
> template <typename _Tp, typename _Alloc>
> void
> deque<_Tp,_Alloc>::
> _M_push_back_aux(const value_type& __t)
> {
> value_type __t_copy = __t;
> _M_reserve_map_at_back();
> *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
> try
> {
> std::_Construct(this->_M_impl._M_finish._M_cur, __t_copy);
> 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)
> {
> value_type __t_copy = __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;
> std::_Construct(this->_M_impl._M_start._M_cur, __t_copy);
> }
> 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;
> std::_Destroy(this->_M_impl._M_finish._M_cur);
> }
>
>
>
>
>
> template <typename _Tp, typename _Alloc>
> void deque<_Tp,_Alloc>::
> _M_pop_front_aux()
> {
> std::_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,
> 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,
> forward_iterator_tag)
> {
> 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(__first, __last, __new_start);
> 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(__first, __last, this->_M_impl._M_finish);
> 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>
> typename deque<_Tp, _Alloc>::iterator
> deque<_Tp,_Alloc>::
> _M_insert_aux(iterator __pos, const value_type& __x)
> {
> difference_type __index = __pos - this->_M_impl._M_start;
> value_type __x_copy = __x;
> 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;
> 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_copy(this->_M_impl._M_start, __start_n,
> __new_start);
> this->_M_impl._M_start = __new_start;
> std::copy(__start_n, __pos, __old_start);
> fill(__pos - difference_type(__n), __pos, __x_copy);
> }
> else
> {
> std::__uninitialized_copy_fill(this->_M_impl._M_start, __pos,
> __new_start,
> this->_M_impl._M_start, __x_copy);
> 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_copy(__finish_n, this->_M_impl._M_finish,
> this->_M_impl._M_finish);
> 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_copy(this->_M_impl._M_finish,
> __pos + difference_type(__n),
> __x_copy, __pos,
> this->_M_impl._M_finish);
> 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;
> 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_copy(this->_M_impl._M_start, __start_n,
> __new_start);
> 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_copy_copy(this->_M_impl._M_start, __pos,
> __first, __mid, __new_start);
> 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_copy(__finish_n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish);
> 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_copy(__mid, __last, __pos,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish);
> 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_new_elements_at_front(size_type __new_elems)
> {
> 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)
> {
> 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)
> {
> size_type __old_num_nodes
> = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
> 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);
> }
>}
># 75 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/deque" 2 3
># 42 "aiLex.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/set" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/set" 3
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/set" 3
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_tree.h" 1 3
># 70 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_tree.h" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/cpp_type_traits.h" 1 3
># 40 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/cpp_type_traits.h" 3
> 
># 41 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/cpp_type_traits.h" 3
># 69 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/cpp_type_traits.h" 3
>namespace __gnu_internal
>{
> typedef char __one;
> typedef char __two[2];
>
> template <typename _Tp>
> __one __test_type (int _Tp::*);
> template <typename _Tp>
> __two& __test_type (...);
>}
>
>namespace std
>{
>
> template<typename, typename>
> struct __are_same
> {
> enum
> {
> _M_type = 0
> };
> };
>
> template<typename _Tp>
> struct __are_same<_Tp, _Tp>
> {
> enum
> {
> _M_type = 1
> };
> };
>
>
> template<typename, bool>
> struct __enable_if
> {
> };
>
> template<typename _Tp>
> struct __enable_if<_Tp, true>
> {
> typedef _Tp _M_type;
> };
>
>
> template<typename _Tp>
> struct __is_void
> {
> enum
> {
> _M_type = 0
> };
> };
>
> template<>
> struct __is_void<void>
> {
> enum
> {
> _M_type = 1
> };
> };
>
>
>
>
> template<typename _Tp>
> struct __is_integer
> {
> enum
> {
> _M_type = 0
> };
> };
>
>
>
>
> template<>
> struct __is_integer<bool>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<char>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<signed char>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<unsigned char>
> {
> enum
> {
> _M_type = 1
> };
> };
>
>
> template<>
> struct __is_integer<wchar_t>
> {
> enum
> {
> _M_type = 1
> };
> };
>
>
> template<>
> struct __is_integer<short>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<unsigned short>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<int>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<unsigned int>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<long>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<unsigned long>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<long long>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_integer<unsigned long long>
> {
> enum
> {
> _M_type = 1
> };
> };
>
>
>
>
> template<typename _Tp>
> struct __is_floating
> {
> enum
> {
> _M_type = 0
> };
> };
>
>
> template<>
> struct __is_floating<float>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_floating<double>
> {
> enum
> {
> _M_type = 1
> };
> };
>
> template<>
> struct __is_floating<long double>
> {
> enum
> {
> _M_type = 1
> };
> };
>
>
>
>
> template<typename _Tp>
> struct __is_arithmetic
> {
> enum
> {
> _M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type
> };
> };
>
>
>
>
> template<typename _Tp>
> struct __is_fundamental
> {
> enum
> {
> _M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type
> };
> };
>
>
>
>
> template<typename _Tp>
> struct __is_pod
> {
> enum
> {
> _M_type = (sizeof(__gnu_internal::__test_type<_Tp>(0))
> != sizeof(__gnu_internal::__one))
> };
> };
>
>}
># 71 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_tree.h" 2 3
>
>namespace std
>{
># 90 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> };
>
> _Rb_tree_node_base*
> _Rb_tree_increment(_Rb_tree_node_base* __x);
>
> const _Rb_tree_node_base*
> _Rb_tree_increment(const _Rb_tree_node_base* __x);
>
> _Rb_tree_node_base*
> _Rb_tree_decrement(_Rb_tree_node_base* __x);
>
> const _Rb_tree_node_base*
> _Rb_tree_decrement(const _Rb_tree_node_base* __x);
>
> 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() { }
>
> _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 &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() { }
>
> _Rb_tree_const_iterator(_Link_type __x)
> : _M_node(__x) { }
>
> _Rb_tree_const_iterator(const iterator& __it)
> : _M_node(__it._M_node) { }
>
> reference
> operator*() const
> { return static_cast<_Link_type>(_M_node)->_M_value_field; }
>
> pointer
> operator->() const
> { return &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_rotate_left(_Rb_tree_node_base* const __x,
> _Rb_tree_node_base*& __root);
>
> void
> _Rb_tree_rotate_right(_Rb_tree_node_base* const __x,
> _Rb_tree_node_base*& __root);
>
> 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);
>
> _Rb_tree_node_base*
> _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
> _Rb_tree_node_base& __header);
>
>
> 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;
> typedef _Rb_tree_node<_Val> _Rb_tree_node;
>
> 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* _Link_type;
> typedef const _Rb_tree_node* _Const_Link_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
>
> protected:
> _Rb_tree_node*
> _M_get_node()
> { return _M_impl._Node_allocator::allocate(1); }
>
> void
> _M_put_node(_Rb_tree_node* __p)
> { _M_impl._Node_allocator::deallocate(__p, 1); }
>
> _Link_type
> _M_create_node(const value_type& __x)
> {
> _Link_type __tmp = _M_get_node();
> try
> { std::_Construct(&__tmp->_M_value_field, __x); }
> catch(...)
> {
> _M_put_node(__tmp);
> throw;
> }
> return __tmp;
> }
>
> _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;
> }
>
> void
> destroy_node(_Link_type __p)
> {
> std::_Destroy(&__p->_M_value_field);
> _M_put_node(__p);
> }
>
> protected:
> template<typename _Key_compare,
> bool _Is_pod_comparator = std::__is_pod<_Key_compare>::_M_type>
> 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(const _Node_allocator& __a = _Node_allocator(),
> const _Key_compare& __comp = _Key_compare())
> : _Node_allocator(__a), _M_key_compare(__comp), _M_node_count(0)
> {
> 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;
> }
> };
>
>
>
> template<typename _Key_compare>
> struct _Rb_tree_impl<_Key_compare, true> : public _Node_allocator
> {
> _Key_compare _M_key_compare;
> _Rb_tree_node_base _M_header;
> size_type _M_node_count;
>
> _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
> const _Key_compare& __comp = _Key_compare())
> : _Node_allocator(__a), _M_key_compare(__comp), _M_node_count(0)
> {
> 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 static_cast<_Link_type>(&this->_M_impl._M_header); }
>
> _Const_Link_type
> _M_end() const
> { return static_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:
> iterator
> _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
>
> _Link_type
> _M_copy(_Const_Link_type __x, _Link_type __p);
>
> void
> _M_erase(_Link_type __x);
>
> public:
>
> _Rb_tree()
> { }
>
> _Rb_tree(const _Compare& __comp)
> : _M_impl(allocator_type(), __comp)
> { }
>
> _Rb_tree(const _Compare& __comp, const allocator_type& __a)
> : _M_impl(__a, __comp)
> { }
>
> _Rb_tree(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x)
> : _M_impl(__x.get_allocator(), __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;
> }
> }
>
> ~_Rb_tree()
> { _M_erase(_M_begin()); }
>
> _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>&
> operator=(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x);
>
>
> _Compare
> key_comp() const
> { return _M_impl._M_key_compare; }
>
> iterator
> begin()
> { return static_cast<_Link_type>(this->_M_impl._M_header._M_left); }
>
> const_iterator
> begin() const
> { return static_cast<_Const_Link_type>(this->_M_impl._M_header._M_left); }
>
> iterator
> end()
> { return static_cast<_Link_type>(&this->_M_impl._M_header); }
>
> const_iterator
> end() const
> { return 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 size_type(-1); }
>
> void
> swap(_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __t);
>
>
> pair<iterator,bool>
> insert_unique(const value_type& __x);
>
> iterator
> insert_equal(const value_type& __x);
>
> iterator
> insert_unique(iterator __position, const value_type& __x);
>
> iterator
> insert_equal(iterator __position, const value_type& __x);
>
> template<typename _InputIterator>
> void
> insert_unique(_InputIterator __first, _InputIterator __last);
>
> template<typename _InputIterator>
> void
> insert_equal(_InputIterator __first, _InputIterator __last);
>
> void
> erase(iterator __position);
>
> size_type
> erase(const key_type& __x);
>
> void
> erase(iterator __first, iterator __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& __x);
>
> const_iterator
> find(const key_type& __x) const;
>
> size_type
> count(const key_type& __x) const;
>
> iterator
> lower_bound(const key_type& __x);
>
> const_iterator
> lower_bound(const key_type& __x) const;
>
> iterator
> upper_bound(const key_type& __x);
>
> const_iterator
> upper_bound(const key_type& __x) const;
>
> pair<iterator,iterator>
> equal_range(const key_type& __x);
>
> pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) 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); }
>
> 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)
> {
> _Link_type __z = _M_create_node(__v);
> bool __insert_left;
>
> __insert_left = __x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__p));
>
> _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>::
> insert_equal(const _Val& __v)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _M_insert(__x, __y, __v);
> }
>
> 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);
> }
>
> 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>::
> insert_unique(const _Val& __v)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
> bool __comp = true;
> while (__x != 0)
> {
> __y = __x;
> __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
> __x = __comp ? _S_left(__x) : _S_right(__x);
> }
> iterator __j = iterator(__y);
> if (__comp)
> if (__j == begin())
> return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
> else
> --__j;
> if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
> return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
> return pair<iterator,bool>(__j, 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>::
> insert_unique(iterator __position, const _Val& __v)
> {
> if (__position._M_node == _M_leftmost())
> {
>
> if (size() > 0
> && _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__position._M_node)))
> return _M_insert(__position._M_node, __position._M_node, __v);
>
> else
> return insert_unique(__v).first;
> }
> else if (__position._M_node == _M_end())
> {
>
> if (_M_impl._M_key_compare(_S_key(_M_rightmost()),
> _KeyOfValue()(__v)))
> return _M_insert(0, _M_rightmost(), __v);
> else
> return insert_unique(__v).first;
> }
> else
> {
> iterator __before = __position;
> --__before;
> if (_M_impl._M_key_compare(_S_key(__before._M_node),
> _KeyOfValue()(__v))
> && _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__position._M_node)))
> {
> if (_S_right(__before._M_node) == 0)
> return _M_insert(0, __before._M_node, __v);
> else
> return _M_insert(__position._M_node, __position._M_node, __v);
>
> }
> else
> return insert_unique(__v).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>::
> insert_equal(iterator __position, const _Val& __v)
> {
> if (__position._M_node == _M_leftmost())
> {
>
> if (size() > 0
> && !_M_impl._M_key_compare(_S_key(__position._M_node),
> _KeyOfValue()(__v)))
> return _M_insert(__position._M_node, __position._M_node, __v);
>
> else
> return insert_equal(__v);
> }
> else if (__position._M_node == _M_end())
> {
>
> if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(_M_rightmost())))
> return _M_insert(0, _M_rightmost(), __v);
> else
> return insert_equal(__v);
> }
> else
> {
> iterator __before = __position;
> --__before;
> if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__before._M_node))
> && !_M_impl._M_key_compare(_S_key(__position._M_node),
> _KeyOfValue()(__v)))
> {
> if (_S_right(__before._M_node) == 0)
> return _M_insert(0, __before._M_node, __v);
> else
> return _M_insert(__position._M_node, __position._M_node, __v);
>
> }
> else
> return insert_equal(__v);
> }
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>::
> insert_equal(_II __first, _II __last)
> {
> for ( ; __first != __last; ++__first)
> insert_equal(*__first);
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>::
> insert_unique(_II __first, _II __last)
> {
> for ( ; __first != __last; ++__first)
> insert_unique(*__first);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::erase(iterator __position)
> {
> _Link_type __y =
> static_cast<_Link_type>(_Rb_tree_rebalance_for_erase(__position._M_node,
> this->_M_impl._M_header));
> destroy_node(__y);
> --_M_impl._M_node_count;
> }
>
> 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);
> size_type __n = std::distance(__p.first, __p.second);
> erase(__p.first, __p.second);
> return __n;
> }
>
> 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);
> destroy_node(__x);
> __x = __y;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
> erase(iterator __first, 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>
> 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)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
>
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
>
> iterator __j = iterator(__y);
> 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_Link_type __x = _M_begin();
> _Const_Link_type __y = _M_end();
>
> while (__x != 0)
> {
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> }
> const_iterator __j = const_iterator(__y);
> 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;
> }
>
> 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>::
> lower_bound(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))
> __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>::
> lower_bound(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))
> __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>::
> upper_bound(const _Key& __k)
> {
> _Link_type __x = _M_begin();
> _Link_type __y = _M_end();
>
> 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>::
> upper_bound(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(__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>
> inline
> 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)
> { return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k)); }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Compare, typename _Alloc>
> inline
> pair<typename _Rb_tree<_Key, _Val, _KoV,
> _Compare, _Alloc>::const_iterator,
> typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator>
> _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
> equal_range(const _Key& __k) const
> { return pair<const_iterator, const_iterator>(lower_bound(__k),
> upper_bound(__k)); }
>
> unsigned int
> _Rb_tree_black_count(const _Rb_tree_node_base* __node,
> const _Rb_tree_node_base* __root);
>
> 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;
> }
>}
># 67 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/set" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
>namespace std
>{
>
> template<class _Key, class _Compare = less<_Key>,
> class _Alloc = allocator<_Key> >
> class set;
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y);
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y);
># 106 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> template<class _Key, class _Compare, class _Alloc>
> class set
> {
>
> 
> 
>
>
> public:
>
>
>
> typedef _Key key_type;
> typedef _Key value_type;
> typedef _Compare key_compare;
> typedef _Compare value_compare;
>
>
> private:
> typedef _Rb_tree<key_type, value_type,
> _Identity<value_type>, key_compare, _Alloc> _Rep_type;
> _Rep_type _M_t;
> public:
>
>
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::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;
> typedef typename _Rep_type::allocator_type allocator_type;
>
>
>
>
> set()
> : _M_t(_Compare(), allocator_type()) {}
>
>
>
>
>
>
>
> explicit set(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) {}
># 171 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> template<class _InputIterator>
> set(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_unique(__first, __last); }
># 187 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> template<class _InputIterator>
> set(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a)
> { _M_t.insert_unique(__first, __last); }
># 201 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> set(const set<_Key,_Compare,_Alloc>& __x)
> : _M_t(__x._M_t) { }
># 211 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> set<_Key,_Compare,_Alloc>&
> operator=(const set<_Key, _Compare, _Alloc>& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
>
>
> 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 _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(); }
>
>
> 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(); }
># 293 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> void
> swap(set<_Key,_Compare,_Alloc>& __x)
> { _M_t.swap(__x._M_t); }
># 311 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> pair<iterator,bool>
> insert(const value_type& __x)
> {
> pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x);
> return pair<iterator, bool>(__p.first, __p.second);
> }
># 337 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> iterator
> insert(iterator __position, const value_type& __x)
> {
> typedef typename _Rep_type::iterator _Rep_iterator;
> return _M_t.insert_unique((_Rep_iterator&)__position, __x);
> }
># 352 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> template<class _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_unique(__first, __last); }
># 366 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> void
> erase(iterator __position)
> {
> typedef typename _Rep_type::iterator _Rep_iterator;
> _M_t.erase((_Rep_iterator&)__position);
> }
># 384 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> size_type
> erase(const key_type& __x) { return _M_t.erase(__x); }
># 398 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> void
> erase(iterator __first, iterator __last)
> {
> typedef typename _Rep_type::iterator _Rep_iterator;
> _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
> }
>
>
>
>
>
>
>
> void
> clear()
> { _M_t.clear(); }
># 425 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 443 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 464 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 480 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 505 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> pair<iterator,iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
>
> pair<const_iterator,const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
>
> template<class _K1, class _C1, class _A1>
> friend bool
> operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
>
> template<class _K1, class _C1, class _A1>
> friend bool
> operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
> };
># 534 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 551 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_set.h" 3
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator!=(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator>(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y)
> { return __y < __x; }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator<=(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline bool
> operator>=(const set<_Key,_Compare,_Alloc>& __x,
> const set<_Key,_Compare,_Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<class _Key, class _Compare, class _Alloc>
> inline void
> swap(set<_Key,_Compare,_Alloc>& __x, set<_Key,_Compare,_Alloc>& __y)
> { __x.swap(__y); }
>
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/set" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
>namespace std
>{
>
>
> template <class _Key, class _Compare = less<_Key>,
> class _Alloc = allocator<_Key> >
> class multiset;
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y);
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y);
># 104 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> template <class _Key, class _Compare, class _Alloc>
> class multiset
> {
>
> 
> 
>
>
> public:
>
> typedef _Key key_type;
> typedef _Key value_type;
> typedef _Compare key_compare;
> typedef _Compare value_compare;
>
> private:
>
> typedef _Rb_tree<key_type, value_type,
> _Identity<value_type>, key_compare, _Alloc> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::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;
> typedef typename _Rep_type::allocator_type allocator_type;
>
>
>
>
>
>
> multiset()
> : _M_t(_Compare(), allocator_type()) { }
>
> explicit
> multiset(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) { }
># 164 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> template <class _InputIterator>
> multiset(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_equal(__first, __last); }
># 180 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> template <class _InputIterator>
> multiset(_InputIterator __first, _InputIterator __last,
> const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a)
> { _M_t.insert_equal(__first, __last); }
># 194 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> multiset(const multiset<_Key,_Compare,_Alloc>& __x)
> : _M_t(__x._M_t) { }
># 204 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> multiset<_Key,_Compare,_Alloc>&
> operator=(const multiset<_Key,_Compare,_Alloc>& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
>
>
> 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 _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(); }
>
>
> 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(); }
># 288 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> void
> swap(multiset<_Key,_Compare,_Alloc>& __x)
> { _M_t.swap(__x._M_t); }
># 304 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> iterator
> insert(const value_type& __x)
> { return _M_t.insert_equal(__x); }
># 328 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> iterator
> insert(iterator __position, const value_type& __x)
> {
> typedef typename _Rep_type::iterator _Rep_iterator;
> return _M_t.insert_equal((_Rep_iterator&)__position, __x);
> }
># 343 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> template <class _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_equal(__first, __last); }
># 358 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> void
> erase(iterator __position)
> {
> typedef typename _Rep_type::iterator _Rep_iterator;
> _M_t.erase((_Rep_iterator&)__position);
> }
># 376 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 391 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> void
> erase(iterator __first, iterator __last)
> {
> typedef typename _Rep_type::iterator _Rep_iterator;
> _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
> }
>
>
>
>
>
>
>
> void
> clear()
> { _M_t.clear(); }
># 415 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.count(__x); }
># 433 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 454 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 470 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 495 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> pair<iterator,iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
>
> pair<const_iterator,const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
> template <class _K1, class _C1, class _A1>
> friend bool
> operator== (const multiset<_K1,_C1,_A1>&,
> const multiset<_K1,_C1,_A1>&);
>
> template <class _K1, class _C1, class _A1>
> friend bool
> operator< (const multiset<_K1,_C1,_A1>&,
> const multiset<_K1,_C1,_A1>&);
> };
># 525 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator==(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return __x._M_t == __y._M_t; }
># 542 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multiset.h" 3
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator<(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator!=(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return !(__x == __y); }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator>(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return __y < __x; }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator<=(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return !(__y < __x); }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline bool
> operator>=(const multiset<_Key,_Compare,_Alloc>& __x,
> const multiset<_Key,_Compare,_Alloc>& __y)
> { return !(__x < __y); }
>
>
> template <class _Key, class _Compare, class _Alloc>
> inline void
> swap(multiset<_Key,_Compare,_Alloc>& __x,
> multiset<_Key,_Compare,_Alloc>& __y)
> { __x.swap(__y); }
>
>}
># 69 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/set" 2 3
># 43 "aiLex.h" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/map" 1 3
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/map" 3
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/map" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
>namespace std
>{
># 89 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> template <typename _Key, typename _Tp, typename _Compare = less<_Key>,
> typename _Alloc = allocator<pair<const _Key, _Tp> > >
> class map
> {
>
> 
> 
>
>
> public:
> typedef _Key key_type;
> typedef _Tp mapped_type;
> typedef pair<const _Key, _Tp> value_type;
> typedef _Compare key_compare;
>
> class value_compare
> : public 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 _Rb_tree<key_type, value_type,
> _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::const_reference const_reference;
> typedef typename _Rep_type::allocator_type allocator_type;
> 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(_Compare(), allocator_type()) { }
>
>
>
>
>
> explicit
> map(const _Compare& __comp, const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) { }
># 165 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> map(const map& __x)
> : _M_t(__x._M_t) { }
># 177 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> template <typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_unique(__first, __last); }
># 193 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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, __a)
> { _M_t.insert_unique(__first, __last); }
># 215 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> map&
> operator=(const map& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
> allocator_type
> get_allocator() const
> { return _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(); }
>
>
>
>
>
> 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(); }
># 330 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
> }
># 358 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> pair<iterator,bool>
> insert(const value_type& __x)
> { return _M_t.insert_unique(__x); }
># 382 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> iterator
> insert(iterator position, const value_type& __x)
> { return _M_t.insert_unique(position, __x); }
># 394 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> template <typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_unique(__first, __last); }
># 408 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> void
> erase(iterator __position)
> { _M_t.erase(__position); }
># 423 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 438 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> void
> erase(iterator __first, iterator __last)
> { _M_t.erase(__first, __last); }
># 453 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 496 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
># 511 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
># 523 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
># 538 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
># 553 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 592 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> pair<iterator,iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
># 611 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_map.h" 3
> 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>&);
> };
># 636 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 653 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/map" 2 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 1 3
># 66 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
>namespace std
>{
>
>
> template <typename _Key, typename _Tp,
> typename _Compare = less<_Key>,
> typename _Alloc = allocator<pair<const _Key, _Tp> > >
> class multimap;
>
> 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);
>
> 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);
># 106 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> class multimap
> {
>
> 
> 
>
>
> public:
> typedef _Key key_type;
> typedef _Tp mapped_type;
> typedef pair<const _Key, _Tp> value_type;
> typedef _Compare key_compare;
>
> class value_compare
> : public 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 _Rb_tree<key_type, value_type,
> _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
>
> _Rep_type _M_t;
>
> public:
>
>
> typedef typename _Alloc::pointer pointer;
> typedef typename _Alloc::const_pointer const_pointer;
> typedef typename _Alloc::reference reference;
> typedef typename _Alloc::const_reference const_reference;
> typedef typename _Rep_type::allocator_type allocator_type;
> 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(_Compare(), allocator_type()) { }
>
>
>
>
>
> explicit
> multimap(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_t(__comp, __a) { }
># 181 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> multimap(const multimap& __x)
> : _M_t(__x._M_t) { }
># 193 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> template <typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last)
> : _M_t(_Compare(), allocator_type())
> { _M_t.insert_equal(__first, __last); }
># 209 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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, __a)
> { _M_t.insert_equal(__first, __last); }
># 232 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> multimap&
> operator=(const multimap& __x)
> {
> _M_t = __x._M_t;
> return *this;
> }
>
>
> allocator_type
> get_allocator() const
> { return _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(); }
>
>
>
> 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(); }
># 346 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> iterator
> insert(const value_type& __x)
> { return _M_t.insert_equal(__x); }
># 370 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> iterator
> insert(iterator __position, const value_type& __x)
> { return _M_t.insert_equal(__position, __x); }
># 382 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> template <typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t.insert_equal(__first, __last); }
># 397 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> void
> erase(iterator __position)
> { _M_t.erase(__position); }
># 412 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 427 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> void
> erase(iterator __first, iterator __last)
> { _M_t.erase(__first, __last); }
># 442 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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()); }
># 485 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
># 500 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 524 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> iterator
> lower_bound(const key_type& __x)
> { return _M_t.lower_bound(__x); }
># 539 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
># 576 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> pair<iterator,iterator>
> equal_range(const key_type& __x)
> { return _M_t.equal_range(__x); }
># 593 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_multimap.h" 3
> 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>&);
> };
># 618 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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; }
># 635 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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); }
>}
># 69 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/map" 2 3
># 44 "aiLex.h" 2
># 1 "/usr/include/boost/regex.hpp" 1 3 4
># 28 "/usr/include/boost/regex.hpp" 3 4
># 1 "/usr/include/boost/regex/config.hpp" 1 3 4
># 41 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/regex/user.hpp" 1 3 4
># 42 "/usr/include/boost/regex/config.hpp" 2 3 4
>
># 1 "/usr/include/boost/config.hpp" 1 3 4
># 26 "/usr/include/boost/config.hpp" 3 4
># 1 "/usr/include/boost/config/user.hpp" 1 3 4
># 27 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/select_compiler_config.hpp" 1 3 4
># 32 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/compiler/gcc.hpp" 1 3 4
># 36 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/select_stdlib_config.hpp" 1 3 4
># 20 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/utility" 1 3 4
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/utility" 3 4
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/utility" 3
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_relops.h" 1 3
># 74 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_relops.h" 3
>namespace std
>{
> namespace rel_ops
> {
># 90 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator!=(const _Tp& __x, const _Tp& __y)
> { return !(__x == __y); }
># 103 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>(const _Tp& __x, const _Tp& __y)
> { return __y < __x; }
># 116 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator<=(const _Tp& __x, const _Tp& __y)
> { return !(__y < __x); }
># 129 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>=(const _Tp& __x, const _Tp& __y)
> { return !(__x < __y); }
>
> }
>}
># 68 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/utility" 2 3
># 21 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
># 41 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
># 45 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/select_platform_config.hpp" 1 3 4
># 50 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
># 70 "/usr/include/boost/config/platform/linux.hpp" 3 4
># 1 "/usr/include/boost/config/posix_features.hpp" 1 3 4
># 71 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
># 54 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/suffix.hpp" 1 3 4
># 33 "/usr/include/boost/config/suffix.hpp" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/include/limits.h" 1 3 4
># 34 "/usr/include/boost/config/suffix.hpp" 2 3 4
># 412 "/usr/include/boost/config/suffix.hpp" 3 4
>namespace boost{
>
> __extension__ typedef long long long_long_type;
> __extension__ typedef unsigned long long ulong_long_type;
>
>
>
>
>}
># 58 "/usr/include/boost/config.hpp" 2 3 4
># 44 "/usr/include/boost/regex/config.hpp" 2 3 4
># 101 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/regex/config/cwchar.hpp" 1 3 4
># 49 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
>namespace std{
>
>
>extern "C"{
># 201 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
>}
>
>
>}
># 102 "/usr/include/boost/regex/config.hpp" 2 3 4
># 190 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 191 "/usr/include/boost/regex/config.hpp" 2 3 4
># 358 "/usr/include/boost/regex/config.hpp" 3 4
>namespace boost{ namespace re_detail{
>
> void* get_mem_block();
> void put_mem_block(void*);
>
>}}
># 29 "/usr/include/boost/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex.hpp" 1 3 4
># 32 "/usr/include/boost/regex/v4/regex.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/regex_workaround.hpp" 1 3 4
># 27 "/usr/include/boost/regex/v4/regex_workaround.hpp" 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 1 3 4
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3 4
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 2 3
># 28 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/stdexcept" 1 3 4
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/stdexcept" 3 4
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/stdexcept" 3
>
>
>
>
>namespace std
>{
>
>
>
>
>
> class logic_error : public exception
> {
> string _M_msg;
>
> public:
>
> explicit
> logic_error(const string& __arg);
>
> virtual
> ~logic_error() throw();
>
>
>
> virtual const char*
> what() const throw();
> };
>
>
>
> class domain_error : public logic_error
> {
> public:
> explicit domain_error(const string& __arg);
> };
>
>
> class invalid_argument : public logic_error
> {
> public:
> explicit invalid_argument(const string& __arg);
> };
>
>
>
> class length_error : public logic_error
> {
> public:
> explicit length_error(const string& __arg);
> };
>
>
>
> class out_of_range : public logic_error
> {
> public:
> explicit out_of_range(const string& __arg);
> };
>
>
>
>
>
>
> class runtime_error : public exception
> {
> string _M_msg;
>
> public:
>
> explicit
> runtime_error(const string& __arg);
>
> virtual
> ~runtime_error() throw();
>
>
>
> virtual const char*
> what() const throw();
> };
>
>
> class range_error : public runtime_error
> {
> public:
> explicit range_error(const string& __arg);
> };
>
>
> class overflow_error : public runtime_error
> {
> public:
> explicit overflow_error(const string& __arg);
> };
>
>
> class underflow_error : public runtime_error
> {
> public:
> explicit underflow_error(const string& __arg);
> };
>}
># 30 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iterator" 1 3 4
># 64 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iterator" 3 4
> 
># 65 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iterator" 3
># 73 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iterator" 3
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stream_iterator.h" 1 3
># 38 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stream_iterator.h" 3
> 
># 39 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stream_iterator.h" 3
>
>
>
>namespace std
>{
>
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
> class istream_iterator
> : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
> {
> public:
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
> private:
> istream_type* _M_stream;
> _Tp _M_value;
> bool _M_ok;
>
> public:
>
> istream_iterator()
> : _M_stream(0), _M_ok(false) {}
>
>
> istream_iterator(istream_type& __s)
> : _M_stream(&__s)
> { _M_read(); }
>
> istream_iterator(const istream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
> _M_ok(__obj._M_ok)
> { }
>
> const _Tp&
> operator*() const
> {
> ;
>
>
> return _M_value;
> }
>
> const _Tp*
> operator->() const { return &(operator*()); }
>
> istream_iterator&
> operator++()
> {
> ;
>
>
> _M_read();
> return *this;
> }
>
> istream_iterator
> operator++(int)
> {
> ;
>
>
> istream_iterator __tmp = *this;
> _M_read();
> return __tmp;
> }
>
> bool
> _M_equal(const istream_iterator& __x) const
> { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
>
> private:
> void
> _M_read()
> {
> _M_ok = (_M_stream && *_M_stream) ? true : false;
> if (_M_ok)
> {
> *_M_stream >> _M_value;
> _M_ok = *_M_stream ? true : false;
> }
> }
> };
>
>
> template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
> inline bool
> operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return __x._M_equal(__y); }
>
>
> template <class _Tp, class _CharT, class _Traits, class _Dist>
> inline bool
> operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return !__x._M_equal(__y); }
># 150 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stream_iterator.h" 3
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT> >
> class ostream_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> private:
> ostream_type* _M_stream;
> const _CharT* _M_string;
>
> public:
>
> ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
># 181 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/stream_iterator.h" 3
> ostream_iterator(ostream_type& __s, const _CharT* __c)
> : _M_stream(&__s), _M_string(__c) { }
>
>
> ostream_iterator(const ostream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
>
>
>
> ostream_iterator&
> operator=(const _Tp& __value)
> {
> ;
>
>
> *_M_stream << __value;
> if (_M_string) *_M_stream << _M_string;
> return *this;
> }
>
> ostream_iterator&
> operator*()
> { return *this; }
>
> ostream_iterator&
> operator++()
> { return *this; }
>
> ostream_iterator&
> operator++(int)
> { return *this; }
> };
>}
># 74 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iterator" 2 3
># 31 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/limits.hpp" 1 3 4
># 36 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 35 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 36 "/usr/include/boost/assert.hpp" 2 3 4
># 37 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 54 "/usr/include/boost/cstdint.hpp" 3 4
>namespace boost
>{
>
> using ::int8_t;
> using ::int_least8_t;
> using ::int_fast8_t;
> using ::uint8_t;
> using ::uint_least8_t;
> using ::uint_fast8_t;
>
> using ::int16_t;
> using ::int_least16_t;
> using ::int_fast16_t;
> using ::uint16_t;
> using ::uint_least16_t;
> using ::uint_fast16_t;
>
> using ::int32_t;
> using ::int_least32_t;
> using ::int_fast32_t;
> using ::uint32_t;
> using ::uint_least32_t;
> using ::uint_fast32_t;
>
>
>
> using ::int64_t;
> using ::int_least64_t;
> using ::int_fast64_t;
> using ::uint64_t;
> using ::uint_least64_t;
> using ::uint_fast64_t;
>
>
>
> using ::intmax_t;
> using ::uintmax_t;
>
>}
># 38 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/throw_exception.hpp" 1 3 4
># 28 "/usr/include/boost/throw_exception.hpp" 3 4
>namespace boost
>{
>
>
>
>
>
>
>
>template<class E> inline void throw_exception(E const & e)
>{
> throw e;
>}
>
>
>
>}
># 39 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/scoped_ptr.hpp" 1 3 4
># 14 "/usr/include/boost/scoped_ptr.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 35 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 36 "/usr/include/boost/assert.hpp" 2 3 4
># 15 "/usr/include/boost/scoped_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/checked_delete.hpp" 1 3 4
># 24 "/usr/include/boost/checked_delete.hpp" 3 4
>namespace boost
>{
>
>
>
>template<class T> inline void checked_delete(T * x)
>{
>
> typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
> (void) sizeof(type_must_be_complete);
> delete x;
>}
>
>template<class T> inline void checked_array_delete(T * x)
>{
> typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
> (void) sizeof(type_must_be_complete);
> delete [] x;
>}
>
>template<class T> struct checked_deleter
>{
> typedef void result_type;
> typedef T * argument_type;
>
> void operator()(T * x) const
> {
>
> boost::checked_delete(x);
> }
>};
>
>template<class T> struct checked_array_deleter
>{
> typedef void result_type;
> typedef T * argument_type;
>
> void operator()(T * x) const
> {
> boost::checked_array_delete(x);
> }
>};
>
>}
># 16 "/usr/include/boost/scoped_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4
># 17 "/usr/include/boost/scoped_ptr.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
># 39 "/usr/include/boost/scoped_ptr.hpp" 3 4
>template<class T> class scoped_ptr
>{
>private:
>
> T * ptr;
>
> scoped_ptr(scoped_ptr const &);
> scoped_ptr & operator=(scoped_ptr const &);
>
> typedef scoped_ptr<T> this_type;
>
>public:
>
> typedef T element_type;
>
> explicit scoped_ptr(T * p = 0): ptr(p)
> {
>
>
>
> }
>
>
>
> explicit scoped_ptr(std::auto_ptr<T> p): ptr(p.release())
> {
>
>
>
> }
>
>
>
> ~scoped_ptr()
> {
>
>
>
> boost::checked_delete(ptr);
> }
>
> void reset(T * p = 0)
> {
> (static_cast<void> ((p == 0 || p != ptr) ? 0 : (__assert_fail ("p == 0 || p != ptr", "/usr/include/boost/scoped_ptr.hpp", 82, __PRETTY_FUNCTION__), 0)));
> this_type(p).swap(*this);
> }
>
> T & operator*() const
> {
> (static_cast<void> ((ptr != 0) ? 0 : (__assert_fail ("ptr != 0", "/usr/include/boost/scoped_ptr.hpp", 88, __PRETTY_FUNCTION__), 0)));
> return *ptr;
> }
>
> T * operator->() const
> {
> (static_cast<void> ((ptr != 0) ? 0 : (__assert_fail ("ptr != 0", "/usr/include/boost/scoped_ptr.hpp", 94, __PRETTY_FUNCTION__), 0)));
> return ptr;
> }
>
> T * get() const
> {
> return ptr;
> }
># 121 "/usr/include/boost/scoped_ptr.hpp" 3 4
> typedef T * this_type::*unspecified_bool_type;
>
> operator unspecified_bool_type() const
> {
> return ptr == 0? 0: &this_type::ptr;
> }
>
>
>
> bool operator! () const
> {
> return ptr == 0;
> }
>
> void swap(scoped_ptr & b)
> {
> T * tmp = b.ptr;
> b.ptr = ptr;
> ptr = tmp;
> }
>};
>
>template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
>{
> a.swap(b);
>}
>
>
>
>template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
>{
> return p.get();
>}
>
>}
># 40 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/scoped_array.hpp" 1 3 4
># 14 "/usr/include/boost/scoped_array.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 35 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 36 "/usr/include/boost/assert.hpp" 2 3 4
># 15 "/usr/include/boost/scoped_array.hpp" 2 3 4
>
>
>
>
>
>
>
>namespace boost
>{
># 38 "/usr/include/boost/scoped_array.hpp" 3 4
>template<class T> class scoped_array
>{
>private:
>
> T * ptr;
>
> scoped_array(scoped_array const &);
> scoped_array & operator=(scoped_array const &);
>
> typedef scoped_array<T> this_type;
>
>public:
>
> typedef T element_type;
>
> explicit scoped_array(T * p = 0) : ptr(p)
> {
>
>
>
> }
>
> ~scoped_array()
> {
>
>
>
> boost::checked_array_delete(ptr);
> }
>
> void reset(T * p = 0)
> {
> (static_cast<void> ((p == 0 || p != ptr) ? 0 : (__assert_fail ("p == 0 || p != ptr", "/usr/include/boost/scoped_array.hpp", 70, __PRETTY_FUNCTION__), 0)));
> this_type(p).swap(*this);
> }
>
> T & operator[](std::ptrdiff_t i) const
> {
> (static_cast<void> ((ptr != 0) ? 0 : (__assert_fail ("ptr != 0", "/usr/include/boost/scoped_array.hpp", 76, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((i >= 0) ? 0 : (__assert_fail ("i >= 0", "/usr/include/boost/scoped_array.hpp", 77, __PRETTY_FUNCTION__), 0)));
> return ptr[i];
> }
>
> T * get() const
> {
> return ptr;
> }
># 105 "/usr/include/boost/scoped_array.hpp" 3 4
> typedef T * this_type::*unspecified_bool_type;
>
> operator unspecified_bool_type() const
> {
> return ptr == 0? 0: &this_type::ptr;
> }
>
>
>
> bool operator! () const
> {
> return ptr == 0;
> }
>
> void swap(scoped_array & b)
> {
> T * tmp = b.ptr;
> b.ptr = ptr;
> ptr = tmp;
> }
>
>};
>
>template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b)
>{
> a.swap(b);
>}
>
>}
># 41 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/shared_ptr.hpp" 1 3 4
># 23 "/usr/include/boost/shared_ptr.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 35 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 36 "/usr/include/boost/assert.hpp" 2 3 4
># 24 "/usr/include/boost/shared_ptr.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/detail/shared_count.hpp" 1 3 4
># 28 "/usr/include/boost/detail/shared_count.hpp" 3 4
># 1 "/usr/include/boost/detail/bad_weak_ptr.hpp" 1 3 4
># 26 "/usr/include/boost/detail/bad_weak_ptr.hpp" 3 4
>namespace boost
>{
># 39 "/usr/include/boost/detail/bad_weak_ptr.hpp" 3 4
>class bad_weak_ptr: public std::exception
>{
>public:
>
> virtual char const * what() const throw()
> {
> return "boost::bad_weak_ptr";
> }
>};
>
>
>
>
>
>}
># 29 "/usr/include/boost/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/detail/sp_counted_base.hpp" 1 3 4
># 32 "/usr/include/boost/detail/sp_counted_base.hpp" 3 4
># 1 "/usr/include/boost/detail/sp_counted_base_gcc_x86.hpp" 1 3 4
># 29 "/usr/include/boost/detail/sp_counted_base_gcc_x86.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>inline int atomic_exchange_and_add( int * pw, int dv )
>{
>
>
>
>
> int r;
>
> __asm__ __volatile__
> (
> "lock\n\t"
> "xadd %1, %0":
> "=m"( *pw ), "=r"( r ):
> "m"( *pw ), "1"( dv ):
> "memory", "cc"
> );
>
> return r;
>}
>
>inline void atomic_increment( int * pw )
>{
>
>
> __asm__
> (
> "lock\n\t"
> "incl %0":
> "=m"( *pw ):
> "m"( *pw ):
> "cc"
> );
>}
>
>inline int atomic_conditional_increment( int * pw )
>{
>
>
>
>
> int rv, tmp;
>
> __asm__
> (
> "movl %0, %%eax\n\t"
> "0:\n\t"
> "test %%eax, %%eax\n\t"
> "je 1f\n\t"
> "movl %%eax, %2\n\t"
> "incl %2\n\t"
> "lock\n\t"
> "cmpxchgl %2, %0\n\t"
> "jne 0b\n\t"
> "1:":
> "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ):
> "m"( *pw ):
> "cc"
> );
>
> return rv;
>}
>
>class sp_counted_base
>{
>private:
>
> sp_counted_base( sp_counted_base const & );
> sp_counted_base & operator= ( sp_counted_base const & );
>
> int use_count_;
> int weak_count_;
>
>public:
>
> sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
> {
> }
>
> virtual ~sp_counted_base()
> {
> }
>
>
>
>
> virtual void dispose() = 0;
>
>
>
> virtual void destroy()
> {
> delete this;
> }
>
> virtual void * get_deleter( std::type_info const & ti ) = 0;
>
> void add_ref_copy()
> {
> atomic_increment( &use_count_ );
> }
>
> bool add_ref_lock()
> {
> return atomic_conditional_increment( &use_count_ ) != 0;
> }
>
> void release()
> {
> if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
> {
> dispose();
> weak_release();
> }
> }
>
> void weak_add_ref()
> {
> atomic_increment( &weak_count_ );
> }
>
> void weak_release()
> {
> if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
> {
> destroy();
> }
> }
>
> long use_count() const
> {
> return static_cast<int const volatile &>( use_count_ );
> }
>};
>
>}
>
>}
># 33 "/usr/include/boost/detail/sp_counted_base.hpp" 2 3 4
># 30 "/usr/include/boost/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/detail/sp_counted_impl.hpp" 1 3 4
># 38 "/usr/include/boost/detail/sp_counted_impl.hpp" 3 4
>namespace boost
>{
># 48 "/usr/include/boost/detail/sp_counted_impl.hpp" 3 4
>namespace detail
>{
>
>template<class X> class sp_counted_impl_p: public sp_counted_base
>{
>private:
>
> X * px_;
>
> sp_counted_impl_p( sp_counted_impl_p const & );
> sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
>
> typedef sp_counted_impl_p<X> this_type;
>
>public:
>
> explicit sp_counted_impl_p( X * px ): px_( px )
> {
>
>
>
> }
>
> virtual void dispose()
> {
>
>
>
> boost::checked_delete( px_ );
> }
>
> virtual void * get_deleter( std::type_info const & )
> {
> return 0;
> }
># 111 "/usr/include/boost/detail/sp_counted_impl.hpp" 3 4
>};
># 120 "/usr/include/boost/detail/sp_counted_impl.hpp" 3 4
>template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
>{
>private:
>
> P ptr;
> D del;
>
> sp_counted_impl_pd( sp_counted_impl_pd const & );
> sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
>
> typedef sp_counted_impl_pd<P, D> this_type;
>
>public:
>
>
>
> sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
> {
> }
>
> virtual void dispose()
> {
> del( ptr );
> }
>
> virtual void * get_deleter( std::type_info const & ti )
> {
> return ti == typeid(D)? &del: 0;
> }
># 177 "/usr/include/boost/detail/sp_counted_impl.hpp" 3 4
>};
>
>
>
>
>
>}
>
>}
># 31 "/usr/include/boost/detail/shared_count.hpp" 2 3 4
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/functional" 1 3 4
># 52 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/functional" 3 4
> 
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/functional" 3
># 34 "/usr/include/boost/detail/shared_count.hpp" 2 3 4
>
>
>
>namespace boost
>{
>
>namespace detail
>{
># 50 "/usr/include/boost/detail/shared_count.hpp" 3 4
>class weak_count;
>
>class shared_count
>{
>private:
>
> sp_counted_base * pi_;
>
>
>
>
>
> friend class weak_count;
>
>public:
>
> shared_count(): pi_(0)
>
>
>
> {
> }
>
> template<class Y> explicit shared_count( Y * p ): pi_( 0 )
>
>
>
> {
>
>
> try
> {
> pi_ = new sp_counted_impl_p<Y>( p );
> }
> catch(...)
> {
> boost::checked_delete( p );
> throw;
> }
># 101 "/usr/include/boost/detail/shared_count.hpp" 3 4
> }
>
> template<class P, class D> shared_count(P p, D d): pi_(0)
>
>
>
> {
>
>
> try
> {
> pi_ = new sp_counted_impl_pd<P, D>(p, d);
> }
> catch(...)
> {
> d(p);
> throw;
> }
># 131 "/usr/include/boost/detail/shared_count.hpp" 3 4
> }
>
>
>
>
>
> template<class Y>
> explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
>
>
>
> {
># 152 "/usr/include/boost/detail/shared_count.hpp" 3 4
> r.release();
> }
>
>
>
> ~shared_count()
> {
> if( pi_ != 0 ) pi_->release();
>
>
>
> }
>
> shared_count(shared_count const & r): pi_(r.pi_)
>
>
>
> {
> if( pi_ != 0 ) pi_->add_ref_copy();
> }
>
> explicit shared_count(weak_count const & r);
>
> shared_count & operator= (shared_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if( tmp != 0 ) tmp->add_ref_copy();
> if( pi_ != 0 ) pi_->release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> void swap(shared_count & r)
> {
> sp_counted_base * tmp = r.pi_;
> r.pi_ = pi_;
> pi_ = tmp;
> }
>
> long use_count() const
> {
> return pi_ != 0? pi_->use_count(): 0;
> }
>
> bool unique() const
> {
> return use_count() == 1;
> }
>
> friend inline bool operator==(shared_count const & a, shared_count const & b)
> {
> return a.pi_ == b.pi_;
> }
>
> friend inline bool operator<(shared_count const & a, shared_count const & b)
> {
> return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
> }
>
> void * get_deleter(std::type_info const & ti) const
> {
> return pi_? pi_->get_deleter( ti ): 0;
> }
>};
>
>
>class weak_count
>{
>private:
>
> sp_counted_base * pi_;
>
>
>
>
>
> friend class shared_count;
>
>public:
>
> weak_count(): pi_(0)
>
>
>
> {
> }
>
> weak_count(shared_count const & r): pi_(r.pi_)
>
>
>
> {
> if(pi_ != 0) pi_->weak_add_ref();
> }
>
> weak_count(weak_count const & r): pi_(r.pi_)
>
>
>
> {
> if(pi_ != 0) pi_->weak_add_ref();
> }
>
> ~weak_count()
> {
> if(pi_ != 0) pi_->weak_release();
>
>
>
> }
>
> weak_count & operator= (shared_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
> if(tmp != 0) tmp->weak_add_ref();
> if(pi_ != 0) pi_->weak_release();
> pi_ = tmp;
>
> return *this;
> }
>
> weak_count & operator= (weak_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
> if(tmp != 0) tmp->weak_add_ref();
> if(pi_ != 0) pi_->weak_release();
> pi_ = tmp;
>
> return *this;
> }
>
> void swap(weak_count & r)
> {
> sp_counted_base * tmp = r.pi_;
> r.pi_ = pi_;
> pi_ = tmp;
> }
>
> long use_count() const
> {
> return pi_ != 0? pi_->use_count(): 0;
> }
>
> friend inline bool operator==(weak_count const & a, weak_count const & b)
> {
> return a.pi_ == b.pi_;
> }
>
> friend inline bool operator<(weak_count const & a, weak_count const & b)
> {
> return std::less<sp_counted_base *>()(a.pi_, b.pi_);
> }
>};
>
>inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
>
>
>
>{
> if( pi_ == 0 || !pi_->add_ref_lock() )
> {
> boost::throw_exception( boost::bad_weak_ptr() );
> }
>}
>
>}
>
>}
># 27 "/usr/include/boost/shared_ptr.hpp" 2 3 4
># 40 "/usr/include/boost/shared_ptr.hpp" 3 4
>namespace boost
>{
>
>template<class T> class weak_ptr;
>template<class T> class enable_shared_from_this;
>
>namespace detail
>{
>
>struct static_cast_tag {};
>struct const_cast_tag {};
>struct dynamic_cast_tag {};
>struct polymorphic_cast_tag {};
>
>template<class T> struct shared_ptr_traits
>{
> typedef T & reference;
>};
>
>template<> struct shared_ptr_traits<void>
>{
> typedef void reference;
>};
>
>
>
>template<> struct shared_ptr_traits<void const>
>{
> typedef void reference;
>};
>
>template<> struct shared_ptr_traits<void volatile>
>{
> typedef void reference;
>};
>
>template<> struct shared_ptr_traits<void const volatile>
>{
> typedef void reference;
>};
>
>
>
>
>
>template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, boost::enable_shared_from_this<T> const * pe, Y const * px )
>{
> if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
>}
>
>inline void sp_enable_shared_from_this( shared_count const & , ... )
>{
>}
>
>}
># 105 "/usr/include/boost/shared_ptr.hpp" 3 4
>template<class T> class shared_ptr
>{
>private:
>
>
> typedef shared_ptr<T> this_type;
>
>public:
>
> typedef T element_type;
> typedef T value_type;
> typedef T * pointer;
> typedef typename detail::shared_ptr_traits<T>::reference reference;
>
> shared_ptr(): px(0), pn()
> {
> }
>
> template<class Y>
> explicit shared_ptr( Y * p ): px( p ), pn( p )
> {
> detail::sp_enable_shared_from_this( pn, p, p );
> }
>
>
>
>
>
>
>
> template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
> {
> detail::sp_enable_shared_from_this( pn, p, p );
> }
>
>
>
>
>
>
> shared_ptr & operator=(shared_ptr const & r)
> {
> px = r.px;
> pn = r.pn;
> return *this;
> }
>
>
>
> template<class Y>
> explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
> {
>
> px = r.px;
> }
>
> template<class Y>
> shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn)
> {
> }
>
> template<class Y>
> shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
> {
> }
>
> template<class Y>
> shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
> {
> }
>
> template<class Y>
> shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
> {
> if(px == 0)
> {
> pn = detail::shared_count();
> }
> }
>
> template<class Y>
> shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
> {
> if(px == 0)
> {
> boost::throw_exception(std::bad_cast());
> }
> }
>
>
>
> template<class Y>
> explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
> {
> Y * tmp = r.get();
> pn = detail::shared_count(r);
> detail::sp_enable_shared_from_this( pn, tmp, tmp );
> }
>
>
>
>
>
> template<class Y>
> shared_ptr & operator=(shared_ptr<Y> const & r)
> {
> px = r.px;
> pn = r.pn;
> return *this;
> }
>
>
>
>
>
> template<class Y>
> shared_ptr & operator=(std::auto_ptr<Y> & r)
> {
> this_type(r).swap(*this);
> return *this;
> }
>
>
>
> void reset()
> {
> this_type().swap(*this);
> }
>
> template<class Y> void reset(Y * p)
> {
> (static_cast<void> ((p == 0 || p != px) ? 0 : (__assert_fail ("p == 0 || p != px", "/usr/include/boost/shared_ptr.hpp", 236, __PRETTY_FUNCTION__), 0)));
> this_type(p).swap(*this);
> }
>
> template<class Y, class D> void reset(Y * p, D d)
> {
> this_type(p, d).swap(*this);
> }
>
> reference operator* () const
> {
> (static_cast<void> ((px != 0) ? 0 : (__assert_fail ("px != 0", "/usr/include/boost/shared_ptr.hpp", 247, __PRETTY_FUNCTION__), 0)));
> return *px;
> }
>
> T * operator-> () const
> {
> (static_cast<void> ((px != 0) ? 0 : (__assert_fail ("px != 0", "/usr/include/boost/shared_ptr.hpp", 253, __PRETTY_FUNCTION__), 0)));
> return px;
> }
>
> T * get() const
> {
> return px;
> }
># 284 "/usr/include/boost/shared_ptr.hpp" 3 4
> typedef T * this_type::*unspecified_bool_type;
>
> operator unspecified_bool_type() const
> {
> return px == 0? 0: &this_type::px;
> }
>
>
>
>
>
> bool operator! () const
> {
> return px == 0;
> }
>
> bool unique() const
> {
> return pn.unique();
> }
>
> long use_count() const
> {
> return pn.use_count();
> }
>
> void swap(shared_ptr<T> & other)
> {
> std::swap(px, other.px);
> pn.swap(other.pn);
> }
>
> template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
> {
> return pn < rhs.pn;
> }
>
> void * _internal_get_deleter(std::type_info const & ti) const
> {
> return pn.get_deleter(ti);
> }
>
>
>
>
>
>
>private:
>
> template<class Y> friend class shared_ptr;
> template<class Y> friend class weak_ptr;
>
>
>
>
> T * px;
> detail::shared_count pn;
>
>};
>
>template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr const & b)
>{
> return a.get() == b.get();
>}
>
>template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr const & b)
>{
> return a.get() != b.get();
>}
># 365 "/usr/include/boost/shared_ptr.hpp" 3 4
>template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr const & b)
>{
> return a._internal_less(b);
>}
>
>template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
>{
> a.swap(b);
>}
>
>template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr const & r)
>{
> return shared_ptr<T>(r, detail::static_cast_tag());
>}
>
>template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr const & r)
>{
> return shared_ptr<T>(r, detail::const_cast_tag());
>}
>
>template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr const & r)
>{
> return shared_ptr<T>(r, detail::dynamic_cast_tag());
>}
>
>
>
>template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr const & r)
>{
> return shared_ptr<T>(r, detail::static_cast_tag());
>}
>
>template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr const & r)
>{
> return shared_ptr<T>(r, detail::dynamic_cast_tag());
>}
>
>template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr const & r)
>{
> return shared_ptr<T>(r, detail::polymorphic_cast_tag());
>}
>
>template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr const & r)
>{
> (static_cast<void> ((dynamic_cast<T *>(r.get()) == r.get()) ? 0 : (__assert_fail ("dynamic_cast<T *>(r.get()) == r.get()", "/usr/include/boost/shared_ptr.hpp", 409, __PRETTY_FUNCTION__), 0)));
> return shared_static_cast<T>(r);
>}
>
>
>
>template<class T> inline T * get_pointer(shared_ptr<T> const & p)
>{
> return p.get();
>}
># 437 "/usr/include/boost/shared_ptr.hpp" 3 4
>template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
>
>{
> os << p.get();
> return os;
>}
># 463 "/usr/include/boost/shared_ptr.hpp" 3 4
>template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
>{
> return static_cast<D *>(p._internal_get_deleter(typeid(D)));
>}
>
>
>
>}
># 42 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
>namespace mpl_ { namespace aux {} }
>namespace boost { namespace mpl { using namespace mpl_;
>namespace aux { using namespace mpl_::aux; }
>}}
># 18 "/usr/include/boost/mpl/bool_fwd.hpp" 2 3 4
>
>namespace mpl_ {
>
>template< bool C_ > struct bool_;
>
>
>typedef bool_<true> true_;
>typedef bool_<false> false_;
>
>}
>
>namespace boost { namespace mpl { using ::mpl_::bool_; } }
>namespace boost { namespace mpl { using ::mpl_::true_; } }
>namespace boost { namespace mpl { using ::mpl_::false_; } }
># 43 "/usr/include/boost/regex/v4/regex_workaround.hpp" 2 3 4
># 53 "/usr/include/boost/regex/v4/regex_workaround.hpp" 3 4
>namespace boost{ namespace re_detail{
>
>
>
>
>
>using std::distance;
>
>}}
># 100 "/usr/include/boost/regex/v4/regex_workaround.hpp" 3 4
>namespace boost{ namespace re_detail{
>
>
>
>
>
>
>template <class T>
>inline void pointer_destroy(T* p)
>{ p->~T(); (void)p; }
>
>
>
>
>
>template <class T>
>inline void pointer_construct(T* p, const T& t)
>{ new (p) T(t); }
>
>}}
># 129 "/usr/include/boost/regex/v4/regex_workaround.hpp" 3 4
>namespace boost{ namespace re_detail{
># 151 "/usr/include/boost/regex/v4/regex_workaround.hpp" 3 4
> using std::copy;
>
> inline std::size_t strcpy_s(
> char *strDestination,
> std::size_t sizeInBytes,
> const char *strSource
> )
> {
> if(std::strlen(strSource)+1 > sizeInBytes)
> return 1;
> std::strcpy(strDestination, strSource);
> return 0;
> }
> inline std::size_t strcat_s(
> char *strDestination,
> std::size_t sizeInBytes,
> const char *strSource
> )
> {
> if(std::strlen(strSource) + std::strlen(strDestination) + 1 > sizeInBytes)
> return 1;
> std::strcat(strDestination, strSource);
> return 0;
> }
>
>
>
> inline void overflow_error_if_not_zero(std::size_t i)
> {
> if(i)
> {
> std::overflow_error e("String buffer too small");
> boost::throw_exception(e);
> }
> }
>
>}}
># 33 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/regex_fwd.hpp" 1 3 4
># 27 "/usr/include/boost/regex_fwd.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/regex_fwd.hpp" 1 3 4
># 37 "/usr/include/boost/regex/v4/regex_fwd.hpp" 3 4
>namespace boost{
>
>template <class charT>
>class cpp_regex_traits;
>template <class charT>
>struct c_regex_traits;
>template <class charT>
>class w32_regex_traits;
>
>
>
>
>
>template <class charT, class implementationT = cpp_regex_traits<charT> >
>struct regex_traits;
>
>
>
>
>
>template <class charT, class traits = regex_traits<charT> >
>class basic_regex;
>
>typedef basic_regex<char, regex_traits<char> > regex;
>
>typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
>
>
>}
># 28 "/usr/include/boost/regex_fwd.hpp" 2 3 4
># 37 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/regex_traits.hpp" 1 3 4
># 32 "/usr/include/boost/regex/regex_traits.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/regex_traits.hpp" 1 3 4
># 29 "/usr/include/boost/regex/v4/regex_traits.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/syntax_type.hpp" 1 3 4
># 22 "/usr/include/boost/regex/v4/syntax_type.hpp" 3 4
>namespace boost{
>namespace regex_constants{
>
>typedef unsigned char syntax_type;
>
>
>
>
>static const syntax_type syntax_char = 0;
>static const syntax_type syntax_open_mark = 1;
>static const syntax_type syntax_close_mark = 2;
>static const syntax_type syntax_dollar = 3;
>static const syntax_type syntax_caret = 4;
>static const syntax_type syntax_dot = 5;
>static const syntax_type syntax_star = 6;
>static const syntax_type syntax_plus = 7;
>static const syntax_type syntax_question = 8;
>static const syntax_type syntax_open_set = 9;
>static const syntax_type syntax_close_set = 10;
>static const syntax_type syntax_or = 11;
>static const syntax_type syntax_escape = 12;
>static const syntax_type syntax_dash = 14;
>static const syntax_type syntax_open_brace = 15;
>static const syntax_type syntax_close_brace = 16;
>static const syntax_type syntax_digit = 17;
>static const syntax_type syntax_comma = 27;
>static const syntax_type syntax_equal = 37;
>static const syntax_type syntax_colon = 36;
>static const syntax_type syntax_not = 53;
>
>
>
>static const syntax_type syntax_hash = 13;
>static const syntax_type syntax_newline = 26;
>
>
>
>typedef syntax_type escape_syntax_type;
>
>static const escape_syntax_type escape_type_word_assert = 18;
>static const escape_syntax_type escape_type_not_word_assert = 19;
>static const escape_syntax_type escape_type_control_f = 29;
>static const escape_syntax_type escape_type_control_n = 30;
>static const escape_syntax_type escape_type_control_r = 31;
>static const escape_syntax_type escape_type_control_t = 32;
>static const escape_syntax_type escape_type_control_v = 33;
>static const escape_syntax_type escape_type_ascii_control = 35;
>static const escape_syntax_type escape_type_hex = 34;
>static const escape_syntax_type escape_type_unicode = 0;
>static const escape_syntax_type escape_type_identity = 0;
>static const escape_syntax_type escape_type_backref = syntax_digit;
>static const escape_syntax_type escape_type_decimal = syntax_digit;
>static const escape_syntax_type escape_type_class = 22;
>static const escape_syntax_type escape_type_not_class = 23;
>
>
>
>static const escape_syntax_type escape_type_left_word = 20;
>static const escape_syntax_type escape_type_right_word = 21;
>static const escape_syntax_type escape_type_start_buffer = 24;
>static const escape_syntax_type escape_type_end_buffer = 25;
>static const escape_syntax_type escape_type_control_a = 28;
>static const escape_syntax_type escape_type_e = 38;
>static const escape_syntax_type escape_type_E = 47;
>static const escape_syntax_type escape_type_Q = 48;
>static const escape_syntax_type escape_type_X = 49;
>static const escape_syntax_type escape_type_C = 50;
>static const escape_syntax_type escape_type_Z = 51;
>static const escape_syntax_type escape_type_G = 52;
>
>static const escape_syntax_type escape_type_property = 54;
>static const escape_syntax_type escape_type_not_property = 55;
>static const escape_syntax_type escape_type_named_char = 56;
>
>static const escape_syntax_type syntax_max = 57;
>
>}
>}
># 30 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/error_type.hpp" 1 3 4
># 23 "/usr/include/boost/regex/v4/error_type.hpp" 3 4
>namespace boost{
>
>
>
>namespace regex_constants{
>
>enum error_type{
>
> error_ok = 0,
> error_no_match = 1,
> error_bad_pattern = 2,
> error_collate = 3,
> error_ctype = 4,
> error_escape = 5,
> error_backref = 6,
> error_brack = 7,
> error_paren = 8,
> error_brace = 9,
> error_badbrace = 10,
> error_range = 11,
> error_space = 12,
> error_badrepeat = 13,
> error_end = 14,
> error_size = 15,
> error_right_paren = 16,
> error_empty = 17,
> error_complexity = 18,
> error_stack = 19,
> error_unknown = 20
>};
>
>}
>}
># 33 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_traits_defaults.hpp" 1 3 4
># 39 "/usr/include/boost/regex/v4/regex_traits_defaults.hpp" 3 4
>namespace boost{ namespace re_detail{
>
>
>
>
>
>template <class charT>
>inline bool is_extended(charT c)
>{ return c > 256; }
>inline bool is_extended(char)
>{ return false; }
>
>
> const char* get_default_syntax(regex_constants::syntax_type n);
> const char* get_default_error_string(regex_constants::error_type n);
> regex_constants::syntax_type get_default_syntax_type(char c);
> regex_constants::escape_syntax_type get_default_escape_syntax_type(char c);
>
>
> bool is_combining_implementation(uint_least16_t s);
>
>template <class charT>
>inline bool is_combining(charT c)
>{
> return (c <= static_cast<charT>(0)) ? false : ((c >= static_cast<charT>((std::numeric_limits<uint_least16_t>::max)())) ? false : is_combining_implementation(static_cast<unsigned short>(c)));
>}
>template <>
>inline bool is_combining<char>(char)
>{
> return false;
>}
>template <>
>inline bool is_combining<signed char>(signed char)
>{
> return false;
>}
>template <>
>inline bool is_combining<unsigned char>(unsigned char)
>{
> return false;
>}
># 107 "/usr/include/boost/regex/v4/regex_traits_defaults.hpp" 3 4
>template <class charT>
>inline bool is_separator(charT c)
>{
> return static_cast<bool>((c == static_cast<charT>('\n')) || (c == static_cast<charT>('\r')) || (c == static_cast<charT>('\f')) || (static_cast<boost::uint16_t>(c) == 0x2028u) || (static_cast<boost::uint16_t>(c) == 0x2029u) || (static_cast<boost::uint16_t>(c) == 0x85u));
>
>
>
>
>
>
>}
>template <>
>inline bool is_separator<char>(char c)
>{
> return static_cast<bool>((c == '\n') || (c == '\r') || (c == '\f'));
>}
>
>
>
>
> std::string lookup_default_collate_name(const std::string& name);
>
>
>
>
>
>template <class charT>
>struct character_pointer_range
>{
> const charT* p1;
> const charT* p2;
>
> bool operator < (const character_pointer_range& r)const
> {
> return std::lexicographical_compare(p1, p2, r.p1, r.p2);
> }
> bool operator == (const character_pointer_range& r)const
> {
> return ((p2 - p1) == (r.p2 - r.p1)) && std::equal(p1, p2, r.p1);
> }
>};
>template <class charT>
>int get_default_class_id(const charT* p1, const charT* p2)
>{
> static const charT data[72] = {
> 'a', 'l', 'n', 'u', 'm',
> 'a', 'l', 'p', 'h', 'a',
> 'b', 'l', 'a', 'n', 'k',
> 'c', 'n', 't', 'r', 'l',
> 'd', 'i', 'g', 'i', 't',
> 'g', 'r', 'a', 'p', 'h',
> 'l', 'o', 'w', 'e', 'r',
> 'p', 'r', 'i', 'n', 't',
> 'p', 'u', 'n', 'c', 't',
> 's', 'p', 'a', 'c', 'e',
> 'u', 'n', 'i', 'c', 'o', 'd', 'e',
> 'u', 'p', 'p', 'e', 'r',
> 'w', 'o', 'r', 'd',
> 'x', 'd', 'i', 'g', 'i', 't',
> };
>
> static const character_pointer_range<charT> ranges[19] =
> {
> {data+0, data+5,},
> {data+5, data+10,},
> {data+10, data+15,},
> {data+15, data+20,},
> {data+20, data+21,},
> {data+20, data+25,},
> {data+25, data+30,},
> {data+30, data+31,},
> {data+30, data+35,},
> {data+35, data+40,},
> {data+40, data+45,},
> {data+45, data+46,},
> {data+45, data+50,},
> {data+57, data+58,},
> {data+50, data+57,},
> {data+57, data+62,},
> {data+62, data+63,},
> {data+62, data+66,},
> {data+66, data+72,},
> };
> static const character_pointer_range<charT>* ranges_begin = ranges;
> static const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));
>
> character_pointer_range<charT> t = { p1, p2, };
> const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t);
> if((p != ranges_end) && (t == *p))
> return static_cast<int>(p - ranges);
> return -1;
>}
>
>
>
>
>template <class charT>
>std::ptrdiff_t global_length(const charT* p)
>{
> std::ptrdiff_t n = 0;
> while(*p)
> {
> ++p;
> ++n;
> }
> return n;
>}
>template<>
>inline std::ptrdiff_t global_length<char>(const char* p)
>{
> return (std::strlen)(p);
>}
>
>template<>
>inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
>{
> return (std::wcslen)(p);
>}
>
>template <class charT>
>inline charT global_lower(charT c)
>{
> return c;
>}
>template <class charT>
>inline charT global_upper(charT c)
>{
> return c;
>}
>
> char do_global_lower(char c);
> char do_global_upper(char c);
>
> wchar_t do_global_lower(wchar_t c);
> wchar_t do_global_upper(wchar_t c);
># 257 "/usr/include/boost/regex/v4/regex_traits_defaults.hpp" 3 4
>template<> inline char global_lower<char>(char c){ return do_global_lower(c); }
>template<> inline char global_upper<char>(char c){ return do_global_upper(c); }
>
>template<> inline wchar_t global_lower<wchar_t>(wchar_t c){ return do_global_lower(c); }
>template<> inline wchar_t global_upper<wchar_t>(wchar_t c){ return do_global_upper(c); }
>
>
>
>
>
>
>template <class charT>
>int global_value(charT c)
>{
> static const charT zero = '0';
> static const charT nine = '9';
> static const charT a = 'a';
> static const charT f = 'f';
> static const charT A = 'A';
> static const charT F = 'F';
>
> if(c > f) return -1;
> if(c >= a) return 10 + (c - a);
> if(c > F) return -1;
> if(c >= A) return 10 + (c - A);
> if(c > nine) return -1;
> if(c >= zero) return c - zero;
> return -1;
>}
>template <class charT, class traits>
>int global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
>{
> (void)t;
> int next_value = t.value(*p1, radix);
> if((p1 == p2) || (next_value < 0) || (next_value >= radix))
> return -1;
> int result = 0;
> while(p1 != p2)
> {
> next_value = t.value(*p1, radix);
> if((next_value < 0) || (next_value >= radix))
> break;
> result *= radix;
> result += next_value;
> ++p1;
> }
> return result;
>}
>
>}
>}
># 36 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 1 3 4
># 27 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
># 1 "/usr/include/boost/regex/pattern_except.hpp" 1 3 4
># 30 "/usr/include/boost/regex/pattern_except.hpp" 3 4
>namespace boost{
># 40 "/usr/include/boost/regex/pattern_except.hpp" 3 4
> class regex_error : public std::runtime_error
>{
>public:
> explicit regex_error(const std::string& s, regex_constants::error_type err, std::ptrdiff_t pos);
> explicit regex_error(regex_constants::error_type err);
> ~regex_error() throw();
> regex_constants::error_type code()const
> { return m_error_code; }
> std::ptrdiff_t position()const
> { return m_position; }
> void raise()const;
>private:
> regex_constants::error_type m_error_code;
> std::ptrdiff_t m_position;
>};
>
>typedef regex_error bad_pattern;
>typedef regex_error bad_expression;
>
>namespace re_detail{
>
> void raise_runtime_error(const std::runtime_error& ex);
>
>template <class traits>
>void raise_error(const traits& t, regex_constants::error_type code)
>{
> (void)t;
> std::runtime_error e(t.error_string(code));
> ::boost::re_detail::raise_runtime_error(e);
>}
>
>}
>
>
>
>
>
>
>}
># 28 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/regex/pending/static_mutex.hpp" 1 3 4
># 37 "/usr/include/boost/regex/pending/static_mutex.hpp" 3 4
>namespace boost{
>
>class scoped_static_mutex_lock;
>
>class static_mutex
>{
>public:
> typedef scoped_static_mutex_lock scoped_lock;
> pthread_mutex_t m_mutex;
>};
>
>
>
>class scoped_static_mutex_lock
>{
>public:
> scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
> ~scoped_static_mutex_lock();
> operator void const*()const;
> bool locked()const;
> void lock();
> void unlock();
>private:
> static_mutex& m_mutex;
> bool m_have_lock;
>};
>
>inline scoped_static_mutex_lock::operator void const*()const
>{
> return locked() ? this : 0;
>}
>
>inline bool scoped_static_mutex_lock::locked()const
>{
> return m_have_lock;
>}
>
>}
># 34 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/primary_transform.hpp" 1 3 4
># 27 "/usr/include/boost/regex/v4/primary_transform.hpp" 3 4
>namespace boost{
> namespace re_detail{
>
>
>enum{
> sort_C,
> sort_fixed,
> sort_delim,
> sort_unknown
>};
>
>template <class S, class charT>
>unsigned count_chars(const S& s, charT c)
>{
>
>
>
>
>
>
> unsigned int count = 0;
> for(unsigned pos = 0; pos < s.size(); ++pos)
> {
> if(s[pos] == c) ++count;
> }
> return count;
>}
>
>
>template <class traits, class charT>
>unsigned find_sort_syntax(const traits* pt, charT* delim)
>{
>
>
>
>
> typedef typename traits::string_type string_type;
> typedef typename traits::char_type char_type;
>
>
> (void)pt;
>
> char_type a[2] = {'a', '\0', };
> string_type sa(pt->transform(a, a+1));
> if(sa == a)
> {
> *delim = 0;
> return sort_C;
> }
> char_type A[2] = { 'A', '\0', };
> string_type sA(pt->transform(A, A+1));
> char_type c[2] = { ';', '\0', };
> string_type sc(pt->transform(c, c+1));
>
> int pos = 0;
> while((pos <= static_cast<int>(sa.size())) && (pos <= static_cast<int>(sA.size())) && (sa[pos] == sA[pos])) ++pos;
> --pos;
> if(pos < 0)
> {
> *delim = 0;
> return sort_unknown;
> }
>
>
>
>
> charT maybe_delim = sa[pos];
> if((pos != 0) && (count_chars(sa, maybe_delim) == count_chars(sA, maybe_delim)) && (count_chars(sa, maybe_delim) == count_chars(sc, maybe_delim)))
> {
> *delim = maybe_delim;
> return sort_delim;
> }
>
>
>
> if((sa.size() == sA.size()) && (sa.size() == sc.size()))
> {
>
>
>
> *delim = static_cast<charT>(++pos);
> return sort_fixed;
> }
>
>
>
> *delim = 0;
> return sort_unknown;
>}
>
>
> }
>}
># 37 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/pending/object_cache.hpp" 1 3 4
># 32 "/usr/include/boost/regex/pending/object_cache.hpp" 3 4
>namespace boost{
>
>template <class Key, class Object>
>class object_cache
>{
>public:
> typedef std::pair< ::boost::shared_ptr<Object>, Key const*> value_type;
> typedef std::list<value_type> list_type;
> typedef typename list_type::iterator list_iterator;
> typedef std::map<Key, list_iterator> map_type;
> typedef typename map_type::iterator map_iterator;
> typedef typename list_type::size_type size_type;
> static boost::shared_ptr<Object> get(const Key& k, size_type max_cache_size);
>
>private:
> static boost::shared_ptr<Object> do_get(const Key& k, size_type max_cache_size);
>
> struct data
> {
> list_type cont;
> map_type index;
> };
>
>
>
> friend struct data;
>};
>
>template <class Key, class Object>
>boost::shared_ptr<Object> object_cache<Key, Object>::get(const Key& k, size_type max_cache_size)
>{
>
> static boost::static_mutex mut = { {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, { 0, 0 }}, };
>
> boost::static_mutex::scoped_lock l(mut);
> if(l)
> {
> return do_get(k, max_cache_size);
> }
>
>
>
>
> ::boost::throw_exception(std::runtime_error("Error in thread safety code: could not acquire a lock"));
> return boost::shared_ptr<Object>();
>
>
>
>}
>
>template <class Key, class Object>
>boost::shared_ptr<Object> object_cache<Key, Object>::do_get(const Key& k, size_type max_cache_size)
>{
> typedef typename object_cache<Key, Object>::data object_data;
> typedef typename list_type::size_type list_size_type;
> static object_data s_data;
>
>
>
>
> map_iterator mpos = s_data.index.find(k);
> if(mpos != s_data.index.end())
> {
>
>
>
>
> if(--(s_data.cont.end()) != mpos->second)
> {
>
> list_type temp;
> temp.splice(temp.end(), s_data.cont, mpos->second);
>
> s_data.cont.splice(s_data.cont.end(), temp, temp.begin());
> (static_cast<void> ((*(s_data.cont.back().second) == k) ? 0 : (__assert_fail ("*(s_data.cont.back().second) == k", "/usr/include/boost/regex/pending/object_cache.hpp", 106, __PRETTY_FUNCTION__), 0)));
>
> mpos->second = --(s_data.cont.end());
> (static_cast<void> ((&(mpos->first) == mpos->second->second) ? 0 : (__assert_fail ("&(mpos->first) == mpos->second->second", "/usr/include/boost/regex/pending/object_cache.hpp", 109, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((&(mpos->first) == s_data.cont.back().second) ? 0 : (__assert_fail ("&(mpos->first) == s_data.cont.back().second", "/usr/include/boost/regex/pending/object_cache.hpp", 110, __PRETTY_FUNCTION__), 0)));
> }
> return s_data.cont.back().first;
> }
>
>
>
>
> boost::shared_ptr<Object> result(new Object(k));
>
>
>
> s_data.cont.push_back(value_type(result, 0));
> s_data.index.insert(std::make_pair(k, --(s_data.cont.end())));
> s_data.cont.back().second = &(s_data.index.find(k)->first);
> list_size_type s = s_data.cont.size();
> (static_cast<void> ((s_data.index[k]->first.get() == result.get()) ? 0 : (__assert_fail ("s_data.index[k]->first.get() == result.get()", "/usr/include/boost/regex/pending/object_cache.hpp", 126, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((&(s_data.index.find(k)->first) == s_data.cont.back().second) ? 0 : (__assert_fail ("&(s_data.index.find(k)->first) == s_data.cont.back().second", "/usr/include/boost/regex/pending/object_cache.hpp", 127, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((s_data.index.find(k)->first == k) ? 0 : (__assert_fail ("s_data.index.find(k)->first == k", "/usr/include/boost/regex/pending/object_cache.hpp", 128, __PRETTY_FUNCTION__), 0)));
> if(s > max_cache_size)
> {
>
>
>
>
>
> list_iterator pos = s_data.cont.begin();
> list_iterator last = s_data.cont.end();
> while((pos != last) && (s > max_cache_size))
> {
> if(pos->first.unique())
> {
> list_iterator condemmed(pos);
> ++pos;
>
>
> (static_cast<void> ((s_data.index.find(*(condemmed->second)) != s_data.index.end()) ? 0 : (__assert_fail ("s_data.index.find(*(condemmed->second)) != s_data.index.end()", "/usr/include/boost/regex/pending/object_cache.hpp", 146, __PRETTY_FUNCTION__), 0)));
> s_data.index.erase(*(condemmed->second));
> s_data.cont.erase(condemmed);
> --s;
> }
> else
> --pos;
> }
> (static_cast<void> ((s_data.index[k]->first.get() == result.get()) ? 0 : (__assert_fail ("s_data.index[k]->first.get() == result.get()", "/usr/include/boost/regex/pending/object_cache.hpp", 154, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((&(s_data.index.find(k)->first) == s_data.cont.back().second) ? 0 : (__assert_fail ("&(s_data.index.find(k)->first) == s_data.cont.back().second", "/usr/include/boost/regex/pending/object_cache.hpp", 155, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((s_data.index.find(k)->first == k) ? 0 : (__assert_fail ("s_data.index.find(k)->first == k", "/usr/include/boost/regex/pending/object_cache.hpp", 156, __PRETTY_FUNCTION__), 0)));
> }
> return result;
>}
>
>}
># 40 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 2 3 4
># 51 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
>namespace boost{
>
>
>
>
>template <class charT>
>class cpp_regex_traits;
>
>namespace re_detail{
>
>
>
>
>
>template <class charT,
> class traits = ::std::char_traits<charT> >
>class parser_buf : public ::std::basic_streambuf<charT, traits>
>{
> typedef ::std::basic_streambuf<charT, traits> base_type;
> typedef typename base_type::int_type int_type;
> typedef typename base_type::char_type char_type;
> typedef typename base_type::pos_type pos_type;
> typedef ::std::streamsize streamsize;
> typedef typename base_type::off_type off_type;
>public:
> parser_buf() : base_type() { setbuf(0, 0); }
> const charT* getnext() { return this->gptr(); }
>protected:
> std::basic_streambuf<charT, traits>* setbuf(char_type* s, streamsize n);
> typename parser_buf<charT, traits>::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
> typename parser_buf<charT, traits>::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
>private:
> parser_buf& operator=(const parser_buf&);
> parser_buf(const parser_buf&);
>};
>
>template<class charT, class traits>
>std::basic_streambuf<charT, traits>*
>parser_buf<charT, traits>::setbuf(char_type* s, streamsize n)
>{
> this->setg(s, s, s + n);
> return this;
>}
>
>template<class charT, class traits>
>typename parser_buf<charT, traits>::pos_type
>parser_buf<charT, traits>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
>{
> if(which & ::std::ios_base::out)
> return pos_type(off_type(-1));
> std::ptrdiff_t size = this->egptr() - this->eback();
> std::ptrdiff_t pos = this->gptr() - this->eback();
> charT* g = this->eback();
> switch(way)
> {
> case ::std::ios_base::beg:
> if((off < 0) || (off > size))
> return pos_type(off_type(-1));
> else
> this->setg(g, g + off, g + size);
> break;
> case ::std::ios_base::end:
> if((off < 0) || (off > size))
> return pos_type(off_type(-1));
> else
> this->setg(g, g + size - off, g + size);
> break;
> case ::std::ios_base::cur:
> {
> std::ptrdiff_t newpos = pos + off;
> if((newpos < 0) || (newpos > size))
> return pos_type(off_type(-1));
> else
> this->setg(g, g + newpos, g + size);
> break;
> }
> default: ;
> }
>
>
>
>
> return static_cast<pos_type>(this->gptr() - this->eback());
>
>
>
>}
>
>template<class charT, class traits>
>typename parser_buf<charT, traits>::pos_type
>parser_buf<charT, traits>::seekpos(pos_type sp, ::std::ios_base::openmode which)
>{
> if(which & ::std::ios_base::out)
> return pos_type(off_type(-1));
> off_type size = static_cast<off_type>(this->egptr() - this->eback());
> charT* g = this->eback();
> if(off_type(sp) <= size)
> {
> this->setg(g, g + off_type(sp), g + size);
> }
> return pos_type(off_type(-1));
>}
>
>
>
>
>
>template <class charT>
>struct cpp_regex_traits_base
>{
> cpp_regex_traits_base(const std::locale& l)
> { imbue(l); }
> std::locale imbue(const std::locale& l);
>
> std::locale m_locale;
> std::ctype<charT> const* m_pctype;
>
> std::messages<charT> const* m_pmessages;
>
> std::collate<charT> const* m_pcollate;
>
> bool operator<(const cpp_regex_traits_base& b)const
> {
> if(m_pctype == b.m_pctype)
> {
>
> if(m_pmessages == b.m_pmessages)
> {
> }
> return m_pmessages < b.m_pmessages;
>
>
>
> }
> return m_pctype < b.m_pctype;
> }
> bool operator==(const cpp_regex_traits_base& b)const
> {
> return (m_pctype == b.m_pctype)
>
> && (m_pmessages == b.m_pmessages)
>
> && (m_pcollate == b.m_pcollate);
> }
>};
>
>template <class charT>
>std::locale cpp_regex_traits_base<charT>::imbue(const std::locale& l)
>{
> std::locale result(m_locale);
> m_locale = l;
> m_pctype = &std::use_facet< std::ctype<charT> >(l);
>
> m_pmessages = &std::use_facet< std::messages<charT> >(l);
>
> m_pcollate = &std::use_facet< std::collate<charT> >(l);
> return result;
>}
>
>
>
>
>
>template <class charT>
>class cpp_regex_traits_char_layer : public cpp_regex_traits_base<charT>
>{
> typedef std::basic_string<charT> string_type;
> typedef std::map<charT, regex_constants::syntax_type> map_type;
> typedef typename map_type::const_iterator map_iterator_type;
>public:
> cpp_regex_traits_char_layer(const std::locale& l)
> : cpp_regex_traits_base<charT>(l)
> {
> init();
> }
> cpp_regex_traits_char_layer(const cpp_regex_traits_base<charT>& b)
> : cpp_regex_traits_base<charT>(b)
> {
> init();
> }
> void init();
>
> regex_constants::syntax_type syntax_type(charT c)const
> {
> map_iterator_type i = m_char_map.find(c);
> return ((i == m_char_map.end()) ? 0 : i->second);
> }
> regex_constants::escape_syntax_type escape_syntax_type(charT c) const
> {
> map_iterator_type i = m_char_map.find(c);
> if(i == m_char_map.end())
> {
> if(this->m_pctype->is(std::ctype_base::lower, c)) return regex_constants::escape_type_class;
> if(this->m_pctype->is(std::ctype_base::upper, c)) return regex_constants::escape_type_not_class;
> return 0;
> }
> return i->second;
> }
>
>private:
> string_type get_default_message(regex_constants::syntax_type);
>
> map_type m_char_map;
>};
>
>template <class charT>
>void cpp_regex_traits_char_layer<charT>::init()
>{
>
>
>
>
> typename std::messages<charT>::catalog cat = static_cast<std::messages<char>::catalog>(-1);
>
>
>
> std::string cat_name(cpp_regex_traits<charT>::get_catalog_name());
> if(cat_name.size())
> {
> cat = this->m_pmessages->open(
> cat_name,
> this->m_locale);
> if((int)cat < 0)
> {
> std::string m("Unable to open message catalog: ");
> std::runtime_error err(m + cat_name);
> boost::re_detail::raise_runtime_error(err);
> }
> }
>
>
>
> if((int)cat >= 0)
> {
> try{
> for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
> {
> string_type mss = this->m_pmessages->get(cat, 0, i, get_default_message(i));
> for(typename string_type::size_type j = 0; j < mss.size(); ++j)
> {
> m_char_map[mss[j]] = i;
> }
> }
> this->m_pmessages->close(cat);
> }
> catch(...)
> {
> this->m_pmessages->close(cat);
> throw;
> }
> }
> else
> {
>
> for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
> {
> const char* ptr = get_default_syntax(i);
> while(ptr && *ptr)
> {
> m_char_map[this->m_pctype->widen(*ptr)] = i;
> ++ptr;
> }
> }
>
> }
>
>}
>
>template <class charT>
>typename cpp_regex_traits_char_layer<charT>::string_type
> cpp_regex_traits_char_layer<charT>::get_default_message(regex_constants::syntax_type i)
>{
> const char* ptr = get_default_syntax(i);
> string_type result;
> while(ptr && *ptr)
> {
> result.append(1, this->m_pctype->widen(*ptr));
> ++ptr;
> }
> return result;
>}
>
>
>
>
>template <>
>class cpp_regex_traits_char_layer<char> : public cpp_regex_traits_base<char>
>{
> typedef std::string string_type;
>public:
> cpp_regex_traits_char_layer(const std::locale& l)
> : cpp_regex_traits_base<char>(l)
> {
> init();
> }
> cpp_regex_traits_char_layer(const cpp_regex_traits_base<char>& l)
> : cpp_regex_traits_base<char>(l)
> {
> init();
> }
>
> regex_constants::syntax_type syntax_type(char c)const
> {
> return m_char_map[static_cast<unsigned char>(c)];
> }
> regex_constants::escape_syntax_type escape_syntax_type(char c) const
> {
> return m_char_map[static_cast<unsigned char>(c)];
> }
>
>private:
> regex_constants::syntax_type m_char_map[1u << 8];
> void init();
>};
># 391 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
>template <class charT>
>class cpp_regex_traits_implementation : public cpp_regex_traits_char_layer<charT>
>{
>public:
> typedef typename cpp_regex_traits<charT>::char_class_type char_class_type;
> typedef typename std::ctype<charT>::mask native_mask_type;
>
> static const char_class_type mask_blank = 1u << 24;
> static const char_class_type mask_word = 1u << 25;
> static const char_class_type mask_unicode = 1u << 26;
>
>
> typedef std::basic_string<charT> string_type;
> typedef charT char_type;
>
> cpp_regex_traits_implementation(const std::locale& l)
> : cpp_regex_traits_char_layer<charT>(l), m_is(&m_sbuf)
> {
> init();
> }
> cpp_regex_traits_implementation(const cpp_regex_traits_base<charT>& l)
> : cpp_regex_traits_char_layer<charT>(l), m_is(&m_sbuf)
> {
> init();
> }
> std::string error_string(regex_constants::error_type n) const
> {
> if(!m_error_strings.empty())
> {
> std::map<int, std::string>::const_iterator p = m_error_strings.find(n);
> return (p == m_error_strings.end()) ? std::string(get_default_error_string(n)) : p->second;
> }
> return get_default_error_string(n);
> }
> char_class_type lookup_classname(const charT* p1, const charT* p2) const
> {
> char_class_type result = lookup_classname_imp(p1, p2);
> if(result == 0)
> {
> string_type temp(p1, p2);
> this->m_pctype->tolower(&*temp.begin(), &*temp.begin() + temp.size());
> result = lookup_classname_imp(&*temp.begin(), &*temp.begin() + temp.size());
> }
> return result;
> }
> string_type lookup_collatename(const charT* p1, const charT* p2) const;
> string_type transform_primary(const charT* p1, const charT* p2) const;
> string_type transform(const charT* p1, const charT* p2) const;
> re_detail::parser_buf<charT> m_sbuf;
> std::basic_istream<charT> m_is;
>private:
> std::map<int, std::string> m_error_strings;
> std::map<string_type, char_class_type> m_custom_class_names;
> std::map<string_type, string_type> m_custom_collate_names;
> unsigned m_collate_type;
> charT m_collate_delim;
>
>
>
> char_class_type lookup_classname_imp(const charT* p1, const charT* p2) const;
> void init();
>
>
>
>
>};
>
>
>
>
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_blank;
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_word;
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_unicode;
>
>
>
>
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::string_type
> cpp_regex_traits_implementation<charT>::transform_primary(const charT* p1, const charT* p2) const
>{
># 483 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
> (static_cast<void> ((*p2 == 0) ? 0 : (__assert_fail ("*p2 == 0", "/usr/include/boost/regex/v4/cpp_regex_traits.hpp", 483, __PRETTY_FUNCTION__), 0)));
>
> string_type result;
>
>
>
>
>
> try{
>
>
>
>
> switch(m_collate_type)
> {
> case sort_C:
> case sort_unknown:
>
> {
> result.assign(p1, p2);
> this->m_pctype->tolower(&*result.begin(), &*result.begin() + result.size());
> result = this->m_pcollate->transform(&*result.begin(), &*result.begin() + result.size());
> break;
> }
> case sort_fixed:
> {
>
> result.assign(this->m_pcollate->transform(p1, p2));
> result.erase(this->m_collate_delim);
> break;
> }
> case sort_delim:
>
> result.assign(this->m_pcollate->transform(p1, p2));
> std::size_t i;
> for(i = 0; i < result.size(); ++i)
> {
> if(result[i] == m_collate_delim)
> break;
> }
> result.erase(i);
> break;
> }
> }catch(...){}
> while(result.size() && (charT(0) == *result.rbegin()))
> result.erase(result.size() - 1);
> if(result.empty())
> {
>
> result = string_type(1, charT(0));
> }
> return result;
>}
>
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::string_type
> cpp_regex_traits_implementation<charT>::transform(const charT* p1, const charT* p2) const
>{
># 549 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
> (static_cast<void> ((*p2 == 0) ? 0 : (__assert_fail ("*p2 == 0", "/usr/include/boost/regex/v4/cpp_regex_traits.hpp", 549, __PRETTY_FUNCTION__), 0)));
>
>
>
>
>
> string_type result;
> try{
> result = this->m_pcollate->transform(p1, p2);
># 569 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
> while(result.size() && (charT(0) == *result.rbegin()))
> result.erase(result.size() - 1);
>
> (static_cast<void> ((std::find(result.begin(), result.end(), charT(0)) == result.end()) ? 0 : (__assert_fail ("std::find(result.begin(), result.end(), charT(0)) == result.end()", "/usr/include/boost/regex/v4/cpp_regex_traits.hpp", 572, __PRETTY_FUNCTION__), 0)));
> }
> catch(...)
> {
> }
> return result;
>}
>
>
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::string_type
> cpp_regex_traits_implementation<charT>::lookup_collatename(const charT* p1, const charT* p2) const
>{
> typedef typename std::map<string_type, string_type>::const_iterator iter_type;
> if(m_custom_collate_names.size())
> {
> iter_type pos = m_custom_collate_names.find(string_type(p1, p2));
> if(pos != m_custom_collate_names.end())
> return pos->second;
> }
>
>
>
> std::string name(p1, p2);
>
>
>
>
>
>
> name = lookup_default_collate_name(name);
>
>
>
> if(name.size())
> return string_type(name.begin(), name.end());
># 620 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
> if(p2 - p1 == 1)
> return string_type(1, *p1);
> return string_type();
>}
>
>template <class charT>
>void cpp_regex_traits_implementation<charT>::init()
>{
>
>
> typename std::messages<charT>::catalog cat = static_cast<std::messages<char>::catalog>(-1);
>
>
>
> std::string cat_name(cpp_regex_traits<charT>::get_catalog_name());
> if(cat_name.size())
> {
> cat = this->m_pmessages->open(
> cat_name,
> this->m_locale);
> if((int)cat < 0)
> {
> std::string m("Unable to open message catalog: ");
> std::runtime_error err(m + cat_name);
> boost::re_detail::raise_runtime_error(err);
> }
> }
>
>
>
> if((int)cat >= 0)
> {
>
>
>
> for(boost::regex_constants::error_type i = static_cast<boost::regex_constants::error_type>(0);
> i <= boost::regex_constants::error_unknown;
> i = static_cast<boost::regex_constants::error_type>(i + 1))
> {
> const char* p = get_default_error_string(i);
> string_type default_message;
> while(*p)
> {
> default_message.append(1, this->m_pctype->widen(*p));
> ++p;
> }
> string_type s = this->m_pmessages->get(cat, 0, i+200, default_message);
> std::string result;
> for(std::string::size_type j = 0; j < s.size(); ++j)
> {
> result.append(1, this->m_pctype->narrow(s[j], 0));
> }
> m_error_strings[i] = result;
> }
>
>
>
>
> static const char_class_type masks[14] =
> {
> std::ctype<charT>::alnum,
> std::ctype<charT>::alpha,
> std::ctype<charT>::cntrl,
> std::ctype<charT>::digit,
> std::ctype<charT>::graph,
> std::ctype<charT>::lower,
> std::ctype<charT>::print,
> std::ctype<charT>::punct,
> std::ctype<charT>::space,
> std::ctype<charT>::upper,
> std::ctype<charT>::xdigit,
> cpp_regex_traits_implementation<charT>::mask_blank,
> cpp_regex_traits_implementation<charT>::mask_word,
> cpp_regex_traits_implementation<charT>::mask_unicode,
> };
># 714 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
> static const string_type null_string;
> for(unsigned int j = 0; j <= 13; ++j)
> {
> string_type s(this->m_pmessages->get(cat, 0, j+300, null_string));
> if(s.size())
> this->m_custom_class_names[s] = masks[j];
> }
> }
>
>
>
>
> m_collate_type = re_detail::find_sort_syntax(this, &m_collate_delim);
>}
>
>template <class charT>
>typename cpp_regex_traits_implementation<charT>::char_class_type
> cpp_regex_traits_implementation<charT>::lookup_classname_imp(const charT* p1, const charT* p2) const
>{
>
> static const char_class_type masks[20] =
> {
> 0,
> std::ctype<char>::alnum,
> std::ctype<char>::alpha,
> cpp_regex_traits_implementation<charT>::mask_blank,
> std::ctype<char>::cntrl,
> std::ctype<char>::digit,
> std::ctype<char>::digit,
> std::ctype<char>::graph,
> std::ctype<char>::lower,
> std::ctype<char>::lower,
> std::ctype<char>::print,
> std::ctype<char>::punct,
> std::ctype<char>::space,
> std::ctype<char>::space,
> std::ctype<char>::upper,
> cpp_regex_traits_implementation<charT>::mask_unicode,
> std::ctype<char>::upper,
> std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word,
> std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word,
> std::ctype<char>::xdigit,
> };
># 782 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
> if(m_custom_class_names.size())
> {
> typedef typename std::map<std::basic_string<charT>, char_class_type>::const_iterator map_iter;
> map_iter pos = m_custom_class_names.find(string_type(p1, p2));
> if(pos != m_custom_class_names.end())
> return pos->second;
> }
> std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
> (static_cast<void> ((id < sizeof(masks) / sizeof(masks[0])) ? 0 : (__assert_fail ("id < sizeof(masks) / sizeof(masks[0])", "/usr/include/boost/regex/v4/cpp_regex_traits.hpp", 790, __PRETTY_FUNCTION__), 0)));
> return masks[id];
>}
># 815 "/usr/include/boost/regex/v4/cpp_regex_traits.hpp" 3 4
>template <class charT>
>boost::shared_ptr<cpp_regex_traits_implementation<charT> > create_cpp_regex_traits(const std::locale& l )
>{
> cpp_regex_traits_base<charT> key(l);
> return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);
>}
>
>}
>
>template <class charT>
>class cpp_regex_traits
>{
>private:
> typedef std::ctype<charT> ctype_type;
>public:
> typedef charT char_type;
> typedef std::size_t size_type;
> typedef std::basic_string<char_type> string_type;
> typedef std::locale locale_type;
> typedef boost::uint_least32_t char_class_type;
>
> struct boost_extensions_tag{};
>
> cpp_regex_traits()
> : m_pimpl(re_detail::create_cpp_regex_traits<charT>(std::locale()))
> { }
> static size_type length(const char_type* p)
> {
> return std::char_traits<charT>::length(p);
> }
> regex_constants::syntax_type syntax_type(charT c)const
> {
> return m_pimpl->syntax_type(c);
> }
> regex_constants::escape_syntax_type escape_syntax_type(charT c) const
> {
> return m_pimpl->escape_syntax_type(c);
> }
> charT translate(charT c) const
> {
> return c;
> }
> charT translate_nocase(charT c) const
> {
> return m_pimpl->m_pctype->tolower(c);
> }
> charT translate(charT c, bool icase) const
> {
> return icase ? m_pimpl->m_pctype->tolower(c) : c;
> }
> charT tolower(charT c) const
> {
> return m_pimpl->m_pctype->tolower(c);
> }
> charT toupper(charT c) const
> {
> return m_pimpl->m_pctype->toupper(c);
> }
> string_type transform(const charT* p1, const charT* p2) const
> {
> return m_pimpl->transform(p1, p2);
> }
> string_type transform_primary(const charT* p1, const charT* p2) const
> {
> return m_pimpl->transform_primary(p1, p2);
> }
> char_class_type lookup_classname(const charT* p1, const charT* p2) const
> {
> return m_pimpl->lookup_classname(p1, p2);
> }
> string_type lookup_collatename(const charT* p1, const charT* p2) const
> {
> return m_pimpl->lookup_collatename(p1, p2);
> }
> bool isctype(charT c, char_class_type f) const
> {
>
> typedef typename std::ctype<charT>::mask ctype_mask;
>
> static const ctype_mask mask_base =
> static_cast<ctype_mask>(
> std::ctype<charT>::alnum
> | std::ctype<charT>::alpha
> | std::ctype<charT>::cntrl
> | std::ctype<charT>::digit
> | std::ctype<charT>::graph
> | std::ctype<charT>::lower
> | std::ctype<charT>::print
> | std::ctype<charT>::punct
> | std::ctype<charT>::space
> | std::ctype<charT>::upper
> | std::ctype<charT>::xdigit);
>
> if((f & mask_base)
> && (m_pimpl->m_pctype->is(
> static_cast<ctype_mask>(f & mask_base), c)))
> return true;
> else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_unicode) && re_detail::is_extended(c))
> return true;
> else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
> return true;
> else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_blank)
> && m_pimpl->m_pctype->is(std::ctype<charT>::space, c)
> && !re_detail::is_separator(c))
> return true;
> return false;
>
>
>
> }
> int toi(const charT*& p1, const charT* p2, int radix)const;
> int value(charT c, int radix)const
> {
> const charT* pc = &c;
> return toi(pc, pc + 1, radix);
> }
> locale_type imbue(locale_type l)
> {
> std::locale result(getloc());
> m_pimpl = re_detail::create_cpp_regex_traits<charT>(l);
> return result;
> }
> locale_type getloc()const
> {
> return m_pimpl->m_locale;
> }
> std::string error_string(regex_constants::error_type n) const
> {
> return m_pimpl->error_string(n);
> }
>
>
>
>
>
> static std::string catalog_name(const std::string& name);
> static std::string get_catalog_name();
>
>private:
> boost::shared_ptr<re_detail::cpp_regex_traits_implementation<charT> > m_pimpl;
>
>
>
> static std::string& get_catalog_name_inst();
>
>
> static static_mutex& get_mutex_inst();
>
>};
>
>
>template <class charT>
>int cpp_regex_traits<charT>::toi(const charT*& first, const charT* last, int radix)const
>{
>
> last = std::find(first, last, std::use_facet< std::numpunct<charT> >(m_pimpl->m_is.getloc()).thousands_sep());
> m_pimpl->m_sbuf.pubsetbuf(const_cast<charT*>(static_cast<const charT*>(first)), static_cast<std::streamsize>(last-first));
> m_pimpl->m_is.clear();
> if(std::abs(radix) == 16) m_pimpl->m_is >> std::hex;
> else if(std::abs(radix) == 8) m_pimpl->m_is >> std::oct;
> else m_pimpl->m_is >> std::dec;
> int val;
> if(m_pimpl->m_is >> val)
> {
> first = first + ((last - first) - m_pimpl->m_sbuf.in_avail());
> return val;
> }
> else
> return -1;
>}
>
>template <class charT>
>std::string cpp_regex_traits<charT>::catalog_name(const std::string& name)
>{
>
> static_mutex::scoped_lock lk(get_mutex_inst());
>
> std::string result(get_catalog_name_inst());
> get_catalog_name_inst() = name;
> return result;
>}
>
>template <class charT>
>std::string& cpp_regex_traits<charT>::get_catalog_name_inst()
>{
> static std::string s_name;
> return s_name;
>}
>
>template <class charT>
>std::string cpp_regex_traits<charT>::get_catalog_name()
>{
>
> static_mutex::scoped_lock lk(get_mutex_inst());
>
> std::string result(get_catalog_name_inst());
> return result;
>}
>
>
>template <class charT>
>static_mutex& cpp_regex_traits<charT>::get_mutex_inst()
>{
> static static_mutex s_mutex = { {0, 0, 0, PTHREAD_MUTEX_TIMED_NP, { 0, 0 }}, };
> return s_mutex;
>}
>
>
>
>}
># 40 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/regex/v4/c_regex_traits.hpp" 1 3 4
># 41 "/usr/include/boost/regex/v4/c_regex_traits.hpp" 3 4
>namespace boost{
>
>template <class charT>
>struct c_regex_traits;
>
>template<>
>struct c_regex_traits<char>
>{
> c_regex_traits(){}
> typedef char char_type;
> typedef std::size_t size_type;
> typedef std::string string_type;
> struct locale_type{};
> typedef boost::uint32_t char_class_type;
>
> static size_type length(const char_type* p)
> {
> return (std::strlen)(p);
> }
>
> char translate(char c) const
> {
> return c;
> }
> char translate_nocase(char c) const
> {
> return static_cast<char>((std::tolower)(static_cast<unsigned char>(c)));
> }
>
> static string_type transform(const char* p1, const char* p2);
> static string_type transform_primary(const char* p1, const char* p2);
>
> static char_class_type lookup_classname(const char* p1, const char* p2);
> static string_type lookup_collatename(const char* p1, const char* p2);
>
> static bool isctype(char, char_class_type);
> static int value(char, int);
>
> locale_type imbue(locale_type l)
> { return l; }
> locale_type getloc()const
> { return locale_type(); }
>
>private:
>
> c_regex_traits(const c_regex_traits&);
> c_regex_traits& operator=(const c_regex_traits&);
>};
>
>
>template<>
>struct c_regex_traits<wchar_t>
>{
> c_regex_traits(){}
> typedef wchar_t char_type;
> typedef std::size_t size_type;
> typedef std::wstring string_type;
> struct locale_type{};
> typedef boost::uint32_t char_class_type;
>
> static size_type length(const char_type* p)
> {
> return (std::wcslen)(p);
> }
>
> wchar_t translate(wchar_t c) const
> {
> return c;
> }
> wchar_t translate_nocase(wchar_t c) const
> {
> return (std::towlower)(c);
> }
>
> static string_type transform(const wchar_t* p1, const wchar_t* p2);
> static string_type transform_primary(const wchar_t* p1, const wchar_t* p2);
>
> static char_class_type lookup_classname(const wchar_t* p1, const wchar_t* p2);
> static string_type lookup_collatename(const wchar_t* p1, const wchar_t* p2);
>
> static bool isctype(wchar_t, char_class_type);
> static int value(wchar_t, int);
>
> locale_type imbue(locale_type l)
> { return l; }
> locale_type getloc()const
> { return locale_type(); }
>
>private:
>
> c_regex_traits(const c_regex_traits&);
> c_regex_traits& operator=(const c_regex_traits&);
>};
># 188 "/usr/include/boost/regex/v4/c_regex_traits.hpp" 3 4
>}
># 45 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
># 56 "/usr/include/boost/regex/v4/regex_traits.hpp" 3 4
># 1 "/usr/include/boost/mpl/has_xxx.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
># 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/bool.hpp" 3 4
># 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4
>
>namespace mpl_ {
>struct integral_c_tag { static const int value = 0; };
>}
>namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
># 19 "/usr/include/boost/mpl/bool.hpp" 2 3 4
>
>
>namespace mpl_ {
>
>template< bool C_ > struct bool_
>{
> static const bool value = C_;
> typedef integral_c_tag tag;
> typedef bool_ type;
> typedef bool value_type;
> operator bool() const { return this->value; }
>};
>
>
>template< bool C_ >
>bool const bool_<C_>::value;
>
>
>}
># 19 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 2 3 4
>
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T > struct type_wrapper
>{
> typedef T type;
>};
>
>
>
>
>
>
>template< typename T > struct wrapped_type;
>
>template< typename T > struct wrapped_type< type_wrapper<T> >
>{
> typedef T type;
>};
>
>
>
>
>
>
>
>}}}
># 20 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
># 18 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl { namespace aux {
>
>typedef char (&no_tag)[1];
>typedef char (&yes_tag)[2];
>
>template< bool C_ > struct yes_no_tag
>{
> typedef no_tag type;
>};
>
>template<> struct yes_no_tag<true>
>{
> typedef yes_tag type;
>};
>
>
>template< long n > struct weighted_tag
>{
>
> typedef char (&type)[n];
>
>
>
>
>};
># 56 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
>}}}
># 21 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 2 3 4
># 22 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
># 23 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/cat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/cat.hpp" 2 3 4
># 28 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
># 57 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
># 1 "/usr/include/boost/static_assert.hpp" 1 3 4
># 31 "/usr/include/boost/static_assert.hpp" 3 4
>namespace boost{
>
>
>template <bool x> struct STATIC_ASSERTION_FAILURE;
>
>template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
>
>
>template<int x> struct static_assert_test{};
>
>}
># 58 "/usr/include/boost/regex/v4/regex_traits.hpp" 2 3 4
>
>
>
>
>
>namespace boost{
>
>template <class charT, class implementationT >
>struct regex_traits : public implementationT
>{
> regex_traits() : implementationT() {}
>};
># 78 "/usr/include/boost/regex/v4/regex_traits.hpp" 3 4
>namespace re_detail{
>
>template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_boost_extensions_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper const volatile* , boost::mpl::aux::type_wrapper<typename U::boost_extensions_tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
># 89 "/usr/include/boost/regex/v4/regex_traits.hpp" 3 4
>template <class BaseT>
>struct default_wrapper : public BaseT
>{
> typedef typename BaseT::char_type char_type;
> std::string error_string(::boost::regex_constants::error_type e)const
> {
> return ::boost::re_detail::get_default_error_string(e);
> }
> ::boost::regex_constants::syntax_type syntax_type(char_type c)const
> {
> return ((c & 0x7f) == c) ? get_default_syntax_type(static_cast<char>(c)) : ::boost::regex_constants::syntax_char;
> }
> ::boost::regex_constants::escape_syntax_type escape_syntax_type(char_type c)const
> {
> return ((c & 0x7f) == c) ? get_default_escape_syntax_type(static_cast<char>(c)) : ::boost::regex_constants::escape_type_identity;
> }
> int toi(const char_type*& p1, const char_type* p2, int radix)const
> {
> return ::boost::re_detail::global_toi(p1, p2, radix, *this);
> }
> char_type translate(char_type c, bool icase)const
> {
> return (icase ? this->translate_nocase(c) : this->translate(c));
> }
> char_type translate(char_type c)const
> {
> return BaseT::translate(c);
> }
> char_type tolower(char_type c)const
> {
> return ::boost::re_detail::global_lower(c);
> }
> char_type toupper(char_type c)const
> {
> return ::boost::re_detail::global_upper(c);
> }
>};
>
>template <class BaseT, bool has_extensions>
>struct compute_wrapper_base
>{
> typedef BaseT type;
>};
>
>template <class BaseT>
>struct compute_wrapper_base<BaseT, false>
>{
> typedef default_wrapper<BaseT> type;
>};
># 153 "/usr/include/boost/regex/v4/regex_traits.hpp" 3 4
>}
>
>template <class BaseT>
>struct regex_traits_wrapper
> : public ::boost::re_detail::compute_wrapper_base<
> BaseT,
> ::boost::re_detail::has_boost_extensions_tag<BaseT>::value
> >::type
>{
> regex_traits_wrapper(){}
>private:
> regex_traits_wrapper(const regex_traits_wrapper&);
> regex_traits_wrapper& operator=(const regex_traits_wrapper&);
>};
>
>}
># 33 "/usr/include/boost/regex/regex_traits.hpp" 2 3 4
># 40 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/regex/v4/match_flags.hpp" 1 3 4
># 23 "/usr/include/boost/regex/v4/match_flags.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 24 "/usr/include/boost/regex/v4/match_flags.hpp" 2 3 4
>
>
>
>
>
>namespace boost{
> namespace regex_constants{
>
>
>typedef enum _match_flags
>{
> match_default = 0,
> match_not_bol = 1,
> match_not_eol = match_not_bol << 1,
> match_not_bob = match_not_eol << 1,
> match_not_eob = match_not_bob << 1,
> match_not_bow = match_not_eob << 1,
> match_not_eow = match_not_bow << 1,
> match_not_dot_newline = match_not_eow << 1,
> match_not_dot_null = match_not_dot_newline << 1,
> match_prev_avail = match_not_dot_null << 1,
> match_init = match_prev_avail << 1,
> match_any = match_init << 1,
> match_not_null = match_any << 1,
> match_continuous = match_not_null << 1,
>
> match_partial = match_continuous << 1,
>
> match_stop = match_partial << 1,
> match_not_initial_null = match_stop,
> match_all = match_stop << 1,
> match_perl = match_all << 1,
> match_posix = match_perl << 1,
> match_nosubs = match_posix << 1,
> match_extra = match_nosubs << 1,
> match_single_line = match_extra << 1,
> match_unused1 = match_single_line << 1,
> match_unused2 = match_unused1 << 1,
> match_unused3 = match_unused2 << 1,
> match_max = match_unused3,
>
> format_perl = 0,
> format_default = 0,
> format_sed = match_max << 1,
> format_all = format_sed << 1,
> format_no_copy = format_all << 1,
> format_first_only = format_no_copy << 1,
> format_is_if = format_first_only << 1,
> format_literal = format_is_if << 1
>
>} match_flags;
>
>
>
>
>typedef match_flags match_flag_type;
>
>
>
>inline match_flags operator&(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
>inline match_flags operator|(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
>inline match_flags operator^(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
>inline match_flags operator~(match_flags m1)
>{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
>inline match_flags& operator&=(match_flags& m1, match_flags m2)
>{ m1 = m1&m2; return m1; }
>inline match_flags& operator|=(match_flags& m1, match_flags m2)
>{ m1 = m1|m2; return m1; }
>inline match_flags& operator^=(match_flags& m1, match_flags m2)
>{ m1 = m1^m2; return m1; }
>
>
>
>
>}
>
>
>
>using regex_constants::match_flag_type;
>using regex_constants::match_default;
>using regex_constants::match_not_bol;
>using regex_constants::match_not_eol;
>using regex_constants::match_not_bob;
>using regex_constants::match_not_eob;
>using regex_constants::match_not_bow;
>using regex_constants::match_not_eow;
>using regex_constants::match_not_dot_newline;
>using regex_constants::match_not_dot_null;
>using regex_constants::match_prev_avail;
>
>using regex_constants::match_any;
>using regex_constants::match_not_null;
>using regex_constants::match_continuous;
>using regex_constants::match_partial;
>
>using regex_constants::match_all;
>using regex_constants::match_perl;
>using regex_constants::match_posix;
>using regex_constants::match_nosubs;
>using regex_constants::match_extra;
>using regex_constants::match_single_line;
>
>using regex_constants::format_all;
>using regex_constants::format_sed;
>using regex_constants::format_perl;
>using regex_constants::format_default;
>using regex_constants::format_no_copy;
>using regex_constants::format_first_only;
>
>
>}
># 46 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_raw_buffer.hpp" 1 3 4
># 30 "/usr/include/boost/regex/v4/regex_raw_buffer.hpp" 3 4
>namespace boost{
> namespace re_detail{
>
>
>
>
>
>struct empty_padding{};
>
>union padding
>{
> void* p;
> unsigned int i;
>};
>
>template <int N>
>struct padding3
>{
> enum{
> padding_size = 8,
> padding_mask = 7
> };
>};
>
>template<>
>struct padding3<2>
>{
> enum{
> padding_size = 2,
> padding_mask = 1
> };
>};
>
>template<>
>struct padding3<4>
>{
> enum{
> padding_size = 4,
> padding_mask = 3
> };
>};
>
>template<>
>struct padding3<8>
>{
> enum{
> padding_size = 8,
> padding_mask = 7
> };
>};
>
>template<>
>struct padding3<16>
>{
> enum{
> padding_size = 16,
> padding_mask = 15
> };
>};
>
>enum{
> padding_size = padding3<sizeof(padding)>::padding_size,
> padding_mask = padding3<sizeof(padding)>::padding_mask
>};
>
>
>
>
>
>
>
>class raw_storage
>{
>public:
> typedef std::size_t size_type;
> typedef unsigned char* pointer;
>private:
> pointer last, start, end;
>public:
>
> raw_storage();
> raw_storage(size_type n);
>
> ~raw_storage()
> {
> ::operator delete(start);
> }
>
> void resize(size_type n);
>
> void* extend(size_type n)
> {
> if(size_type(last - end) < n)
> resize(n + (end - start));
> register pointer result = end;
> end += n;
> return result;
> }
>
> void* insert(size_type pos, size_type n);
>
> size_type size()
> {
> return end - start;
> }
>
> size_type capacity()
> {
> return last - start;
> }
>
> void* data()const
> {
> return start;
> }
>
> size_type index(void* ptr)
> {
> return static_cast<pointer>(ptr) - static_cast<pointer>(data());
> }
>
> void clear()
> {
> end = start;
> }
>
> void align()
> {
>
> end = start + (((end - start) + padding_mask) & ~padding_mask);
> }
> void swap(raw_storage& that)
> {
> std::swap(start, that.start);
> std::swap(end, that.end);
> std::swap(last, that.last);
> }
>};
>
>inline raw_storage::raw_storage()
>{
> last = start = end = 0;
>}
>
>inline raw_storage::raw_storage(size_type n)
>{
> start = end = static_cast<pointer>(::operator new(n));
> 
> last = start + n;
>}
>
>
>
>
>
>
>}
>}
># 49 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/regex/v4/char_regex_traits.hpp" 1 3 4
># 27 "/usr/include/boost/regex/v4/char_regex_traits.hpp" 3 4
>namespace boost{
>
>namespace deprecated{
>
>
>
>template <class charT>
>class char_regex_traits_i : public regex_traits<charT> {};
>
>template<>
>class char_regex_traits_i<char> : public regex_traits<char>
>{
>public:
> typedef char char_type;
> typedef unsigned char uchar_type;
> typedef unsigned int size_type;
> typedef regex_traits<char> base_type;
>
>};
>
>
>template<>
>class char_regex_traits_i<wchar_t> : public regex_traits<wchar_t>
>{
>public:
> typedef wchar_t char_type;
> typedef unsigned short uchar_type;
> typedef unsigned int size_type;
> typedef regex_traits<wchar_t> base_type;
>
>};
>
>}
>}
># 56 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/states.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/states.hpp" 3 4
>namespace boost{
>namespace re_detail{
>
>
>
>
>
>
>
>enum mask_type
>{
> mask_take = 1,
> mask_skip = 2,
> mask_init = 4,
> mask_any = mask_skip | mask_take,
> mask_all = mask_any
>};
>
>
>
>
>
>struct _narrow_type{};
>struct _wide_type{};
>template <class charT> struct is_byte;
>template<> struct is_byte<char> { typedef _narrow_type width_type; };
>template<> struct is_byte<unsigned char>{ typedef _narrow_type width_type; };
>template<> struct is_byte<signed char> { typedef _narrow_type width_type; };
>template <class charT> struct is_byte { typedef _wide_type width_type; };
>
>
>
>
>enum syntax_element_type
>{
>
> syntax_element_startmark = 0,
>
> syntax_element_endmark = syntax_element_startmark + 1,
>
> syntax_element_literal = syntax_element_endmark + 1,
>
> syntax_element_start_line = syntax_element_literal + 1,
>
> syntax_element_end_line = syntax_element_start_line + 1,
>
> syntax_element_wild = syntax_element_end_line + 1,
>
> syntax_element_match = syntax_element_wild + 1,
>
> syntax_element_word_boundary = syntax_element_match + 1,
>
> syntax_element_within_word = syntax_element_word_boundary + 1,
>
> syntax_element_word_start = syntax_element_within_word + 1,
>
> syntax_element_word_end = syntax_element_word_start + 1,
>
> syntax_element_buffer_start = syntax_element_word_end + 1,
>
> syntax_element_buffer_end = syntax_element_buffer_start + 1,
>
> syntax_element_backref = syntax_element_buffer_end + 1,
>
> syntax_element_long_set = syntax_element_backref + 1,
>
> syntax_element_set = syntax_element_long_set + 1,
>
> syntax_element_jump = syntax_element_set + 1,
>
> syntax_element_alt = syntax_element_jump + 1,
>
> syntax_element_rep = syntax_element_alt + 1,
>
> syntax_element_combining = syntax_element_rep + 1,
>
> syntax_element_soft_buffer_end = syntax_element_combining + 1,
>
> syntax_element_restart_continue = syntax_element_soft_buffer_end + 1,
>
> syntax_element_dot_rep = syntax_element_restart_continue + 1,
> syntax_element_char_rep = syntax_element_dot_rep + 1,
> syntax_element_short_set_rep = syntax_element_char_rep + 1,
> syntax_element_long_set_rep = syntax_element_short_set_rep + 1,
>
> syntax_element_backstep = syntax_element_long_set_rep + 1,
>
> syntax_element_assert_backref = syntax_element_backstep + 1,
> syntax_element_toggle_case = syntax_element_assert_backref + 1
>};
>
>
>
>
>
>
>struct re_syntax_base;
>
>
>
>
>
>
>union offset_type
>{
> re_syntax_base* p;
> std::ptrdiff_t i;
>};
>
>
>
>
>struct re_syntax_base
>{
> syntax_element_type type;
> offset_type next;
>};
>
>
>
>
>struct re_brace : public re_syntax_base
>{
>
>
> int index;
>};
>
>
>
>
>enum
>{
> dont_care = 1,
> force_not_newline = 0,
> force_newline = 2,
>
> test_not_newline = 2,
> test_newline = 3
>};
>struct re_dot : public re_syntax_base
>{
> unsigned char mask;
>};
>
>
>
>
>
>struct re_literal : public re_syntax_base
>{
> unsigned int length;
>};
>
>
>
>
>struct re_case : public re_syntax_base
>{
> bool icase;
>};
># 195 "/usr/include/boost/regex/v4/states.hpp" 3 4
>template <class mask_type>
>struct re_set_long : public re_syntax_base
>{
> unsigned int csingles, cranges, cequivalents;
> mask_type cclasses;
> bool isnot;
> bool singleton;
>};
>
>
>
>
>struct re_set : public re_syntax_base
>{
> unsigned char _map[1 << 8];
>};
>
>
>
>
>struct re_jump : public re_syntax_base
>{
> offset_type alt;
>};
>
>
>
>
>struct re_alt : public re_jump
>{
> unsigned char _map[1 << 8];
> unsigned int can_be_null;
>};
>
>
>
>
>struct re_repeat : public re_alt
>{
> std::size_t min, max;
> int id;
> bool leading;
> bool greedy;
>};
>
>
>
>
>
>
>enum re_jump_size_type
>{
> re_jump_size = (sizeof(re_jump) + padding_mask) & ~(padding_mask),
> re_repeater_size = (sizeof(re_repeat) + padding_mask) & ~(padding_mask),
> re_alt_size = (sizeof(re_alt) + padding_mask) & ~(padding_mask)
>};
>
>
>
>
>
>template<class charT, class traits>
>struct regex_data;
>
>template <class iterator, class charT, class traits_type, class char_classT>
>iterator re_is_set_member(iterator next,
> iterator last,
> const re_set_long<char_classT>* set_,
> const regex_data<charT, traits_type>& e, bool icase);
>
>}
>
>}
># 59 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regbase.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/regbase.hpp" 3 4
>namespace boost{
>
>
>
>
>class regbase
>{
>public:
> enum flag_type_
> {
># 46 "/usr/include/boost/regex/v4/regbase.hpp" 3 4
> perl_syntax_group = 0,
> basic_syntax_group = 1,
> literal = 2,
> main_option_type = literal | basic_syntax_group | perl_syntax_group,
>
>
>
> no_bk_refs = 1 << 8,
> no_perl_ex = 1 << 9,
> no_mod_m = 1 << 10,
> mod_x = 1 << 11,
> mod_s = 1 << 12,
> no_mod_s = 1 << 13,
>
>
>
>
> no_char_classes = 1 << 8,
> no_intervals = 1 << 9,
> bk_plus_qm = 1 << 10,
> bk_vbar = 1 << 11,
> emacs_ex = 1 << 12,
>
>
>
>
> no_escape_in_lists = 1 << 16,
> newline_alt = 1 << 17,
> no_except = 1 << 18,
> failbit = 1 << 19,
> icase = 1 << 20,
> nocollate = 0,
> collate = 1 << 21,
> nosubs = 1 << 22,
> optimize = 0,
>
>
>
> basic = basic_syntax_group | collate | no_escape_in_lists,
> extended = no_bk_refs | collate | no_perl_ex | no_escape_in_lists,
> normal = 0,
> emacs = basic_syntax_group | collate | emacs_ex | bk_vbar,
> awk = no_bk_refs | collate | no_perl_ex,
> grep = basic | newline_alt,
> egrep = extended | newline_alt,
> sed = basic,
> perl = normal,
> ECMAScript = normal,
> JavaScript = normal,
> JScript = normal
> };
> typedef unsigned int flag_type;
>
> enum restart_info
> {
> restart_any = 0,
> restart_word = 1,
> restart_line = 2,
> restart_buf = 3,
> restart_continue = 4,
> restart_lit = 5,
> restart_fixed_lit = 6,
> restart_count = 7
> };
>};
>
>
>
>
>namespace regex_constants{
>
> enum flag_type_
> {
>
> no_except = ::boost::regbase::no_except,
> failbit = ::boost::regbase::failbit,
> literal = ::boost::regbase::literal,
> icase = ::boost::regbase::icase,
> nocollate = ::boost::regbase::nocollate,
> collate = ::boost::regbase::collate,
> nosubs = ::boost::regbase::nosubs,
> optimize = ::boost::regbase::optimize,
> bk_plus_qm = ::boost::regbase::bk_plus_qm,
> bk_vbar = ::boost::regbase::bk_vbar,
> no_intervals = ::boost::regbase::no_intervals,
> no_char_classes = ::boost::regbase::no_char_classes,
> no_escape_in_lists = ::boost::regbase::no_escape_in_lists,
> no_mod_m = ::boost::regbase::no_mod_m,
> mod_x = ::boost::regbase::mod_x,
> mod_s = ::boost::regbase::mod_s,
> no_mod_s = ::boost::regbase::no_mod_s,
>
> basic = ::boost::regbase::basic,
> extended = ::boost::regbase::extended,
> normal = ::boost::regbase::normal,
> emacs = ::boost::regbase::emacs,
> awk = ::boost::regbase::awk,
> grep = ::boost::regbase::grep,
> egrep = ::boost::regbase::egrep,
> sed = basic,
> perl = normal,
> ECMAScript = normal,
> JavaScript = normal,
> JScript = normal
> };
> typedef ::boost::regbase::flag_type syntax_option_type;
>
>}
>
>}
># 62 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/iterator_traits.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/iterator_traits.hpp" 3 4
>namespace boost{
>namespace re_detail{
># 97 "/usr/include/boost/regex/v4/iterator_traits.hpp" 3 4
>template <class T>
>struct regex_iterator_traits : public std::iterator_traits<T> {};
>
>
>
>}
>}
># 65 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/basic_regex.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/basic_regex.hpp" 3 4
>namespace boost{
>
>
>
>
>
>namespace re_detail{
>
>
>
>
>template <class charT, class traits>
>class basic_regex_parser;
>
>
>
>
>
>template <class charT, class traits>
>struct regex_data
>{
> typedef regex_constants::syntax_option_type flag_type;
> typedef std::size_t size_type;
>
> regex_data(const ::boost::shared_ptr<
> ::boost::regex_traits_wrapper<traits> >& t)
> : m_ptraits(t) {}
> regex_data()
> : m_ptraits(new ::boost::regex_traits_wrapper<traits>()) {}
>
> ::boost::shared_ptr<
> ::boost::regex_traits_wrapper<traits>
> > m_ptraits;
> flag_type m_flags;
> int m_status;
> const charT* m_expression;
> std::ptrdiff_t m_expression_len;
> size_type m_mark_count;
> re_detail::re_syntax_base* m_first_state;
> unsigned m_restart_type;
> unsigned char m_startmap[1 << 8];
> unsigned int m_can_be_null;
> re_detail::raw_storage m_data;
>};
>
>
>
>
>template <class charT, class traits>
>class basic_regex_implementation
> : public regex_data<charT, traits>
>{
>public:
> typedef regex_constants::syntax_option_type flag_type;
> typedef std::ptrdiff_t difference_type;
> typedef std::size_t size_type;
> typedef typename traits::locale_type locale_type;
> typedef const charT* const_iterator;
>
> basic_regex_implementation(){}
> basic_regex_implementation(const ::boost::shared_ptr<
> ::boost::regex_traits_wrapper<traits> >& t)
> : regex_data<charT, traits>(t) {}
> void assign(const charT* arg_first,
> const charT* arg_last,
> flag_type f)
> {
> regex_data<charT, traits>* pdat = this;
> basic_regex_parser<charT, traits> parser(pdat);
> parser.parse(arg_first, arg_last, f);
> }
>
> locale_type imbue(locale_type l)
> {
> return this->m_ptraits->imbue(l);
> }
> locale_type getloc()const
> {
> return this->m_ptraits->getloc();
> }
> std::basic_string<charT> str()const
> {
> std::basic_string<charT> result;
> if(this->m_status == 0)
> result = std::basic_string<charT>(this->m_expression, this->m_expression_len);
> return result;
> }
> const_iterator expression()const
> {
> return this->m_expression;
> }
>
>
> const_iterator begin()const
> {
> return (!this->m_status ? 0 : this->m_expression);
> }
> const_iterator end()const
> {
> return (!this->m_status ? 0 : this->m_expression + this->m_expression_len);
> }
> flag_type flags()const
> {
> return this->m_flags;
> }
> size_type size()const
> {
> return this->m_expression_len;
> }
> int status()const
> {
> return this->m_status;
> }
> size_type mark_count()const
> {
> return this->m_mark_count;
> }
> const re_detail::re_syntax_base* get_first_state()const
> {
> return this->m_first_state;
> }
> unsigned get_restart_type()const
> {
> return this->m_restart_type;
> }
> const unsigned char* get_map()const
> {
> return this->m_startmap;
> }
> const ::boost::regex_traits_wrapper<traits>& get_traits()const
> {
> return *(this->m_ptraits);
> }
> bool can_be_null()const
> {
> return this->m_can_be_null;
> }
> const regex_data<charT, traits>& get_data()const
> {
> basic_regex_implementation<charT, traits> const* p = this;
> return *static_cast<const regex_data<charT, traits>*>(p);
> }
>};
>
>}
># 180 "/usr/include/boost/regex/v4/basic_regex.hpp" 3 4
>template <class charT, class traits >
>
>class basic_regex : public regbase
>{
>public:
>
> typedef typename traits::size_type traits_size_type;
> typedef typename traits::string_type traits_string_type;
> typedef charT char_type;
> typedef traits traits_type;
>
> typedef charT value_type;
> typedef charT& reference;
> typedef const charT& const_reference;
> typedef const charT* const_iterator;
> typedef const_iterator iterator;
> typedef std::ptrdiff_t difference_type;
> typedef std::size_t size_type;
> typedef regex_constants::syntax_option_type flag_type;
>
>
>
> typedef typename traits::locale_type locale_type;
>
>public:
> explicit basic_regex(){}
> explicit basic_regex(const charT* p, flag_type f = regex_constants::normal)
> {
> assign(p, f);
> }
> basic_regex(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
> {
> assign(p1, p2, f);
> }
> basic_regex(const charT* p, size_type len, flag_type f)
> {
> assign(p, len, f);
> }
> basic_regex(const basic_regex& that)
> : m_pimpl(that.m_pimpl) {}
> ~basic_regex(){}
> basic_regex& operator=(const basic_regex& that)
> {
> return assign(that);
> }
> basic_regex& operator=(const charT* ptr)
> {
> return assign(ptr);
> }
>
>
>
> basic_regex& assign(const basic_regex& that)
> {
> m_pimpl = that.m_pimpl;
> return *this;
> }
> basic_regex& assign(const charT* p, flag_type f = regex_constants::normal)
> {
> return assign(p, p + traits::length(p), f);
> }
> basic_regex& assign(const charT* p, size_type len, flag_type f)
> {
> return assign(p, p + len, f);
> }
>
> basic_regex& assign(const charT* p1,
> const charT* p2,
> flag_type f = regex_constants::normal);
>
>
> template <class ST, class SA>
> unsigned int set_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
> {
> return set_expression(p.data(), p.data() + p.size(), f);
> }
>
> template <class ST, class SA>
> explicit basic_regex(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
> {
> assign(p, f);
> }
>
> template <class InputIterator>
> basic_regex(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)
> {
> typedef typename traits::string_type seq_type;
> seq_type a(arg_first, arg_last);
> assign(&*a.begin(), &*a.begin() + a.size(), f);
> }
>
> template <class ST, class SA>
> basic_regex& operator=(const std::basic_string<charT, ST, SA>& p)
> {
> return assign(p.data(), p.data() + p.size(), regex_constants::normal);
> }
>
> template <class string_traits, class A>
> basic_regex& assign(
> const std::basic_string<charT, string_traits, A>& s,
> flag_type f = regex_constants::normal)
> {
> return assign(s.data(), s.data() + s.size(), f);
> }
>
> template <class InputIterator>
> basic_regex& assign(InputIterator arg_first,
> InputIterator arg_last,
> flag_type f = regex_constants::normal)
> {
> typedef typename traits::string_type seq_type;
> seq_type a(arg_first, arg_last);
> const charT* p1 = &*a.begin();
> const charT* p2 = &*a.begin() + a.size();
> return assign(p1, p2, f);
> }
># 323 "/usr/include/boost/regex/v4/basic_regex.hpp" 3 4
> locale_type imbue(locale_type l);
> locale_type getloc()const
> {
> return m_pimpl.get() ? m_pimpl->getloc() : locale_type();
> }
>
>
>
>
> flag_type getflags()const
> {
> return flags();
> }
> flag_type flags()const
> {
> return m_pimpl.get() ? m_pimpl->flags() : 0;
> }
>
>
> std::basic_string<charT> str()const
> {
> return m_pimpl.get() ? m_pimpl->str() : std::basic_string<charT>();
> }
>
>
> const_iterator begin()const
> {
> return (m_pimpl.get() ? m_pimpl->begin() : 0);
> }
> const_iterator end()const
> {
> return (m_pimpl.get() ? m_pimpl->end() : 0);
> }
>
>
> void swap(basic_regex& that)throw()
> {
> m_pimpl.swap(that.m_pimpl);
> }
>
>
> size_type size()const
> {
> return (m_pimpl.get() ? m_pimpl->size() : 0);
> }
>
>
> size_type max_size()const
> {
> return (2147483647 * 2U + 1U);
> }
>
>
> bool empty()const
> {
> return (m_pimpl.get() ? 0 != m_pimpl->status() : 0);
> }
>
> size_type mark_count()const
> {
> return (m_pimpl.get() ? m_pimpl->mark_count() : 0);
> }
>
> int status()const
> {
> return (m_pimpl.get() ? m_pimpl->status() : regex_constants::error_empty);
> }
>
> int compare(const basic_regex& that) const
> {
> if(m_pimpl.get() == that.m_pimpl.get())
> return 0;
> if(!m_pimpl.get())
> return -1;
> if(!that.m_pimpl.get())
> return 1;
> if(status() != that.status())
> return status() - that.status();
> if(flags() != that.flags())
> return flags() - that.flags();
> return str().compare(that.str());
> }
> bool operator==(const basic_regex& e)const
> {
> return compare(e) == 0;
> }
> bool operator != (const basic_regex& e)const
> {
> return compare(e) != 0;
> }
> bool operator<(const basic_regex& e)const
> {
> return compare(e) < 0;
> }
> bool operator>(const basic_regex& e)const
> {
> return compare(e) > 0;
> }
> bool operator<=(const basic_regex& e)const
> {
> return compare(e) <= 0;
> }
> bool operator>=(const basic_regex& e)const
> {
> return compare(e) >= 0;
> }
>
>
>
>
> const charT* expression()const
> {
> return (m_pimpl.get() && !m_pimpl->status() ? m_pimpl->expression() : 0);
> }
> unsigned int set_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
> {
> assign(p1, p2, f | regex_constants::no_except);
> return status();
> }
> unsigned int set_expression(const charT* p, flag_type f = regex_constants::normal)
> {
> assign(p, f | regex_constants::no_except);
> return status();
> }
> unsigned int error_code()const
> {
> return status();
> }
>
>
>
> const re_detail::re_syntax_base* get_first_state()const
> {
> (static_cast<void> ((0 != m_pimpl.get()) ? 0 : (__assert_fail ("0 != m_pimpl.get()", "/usr/include/boost/regex/v4/basic_regex.hpp", 456, __PRETTY_FUNCTION__), 0)));
> return m_pimpl->get_first_state();
> }
> unsigned get_restart_type()const
> {
> (static_cast<void> ((0 != m_pimpl.get()) ? 0 : (__assert_fail ("0 != m_pimpl.get()", "/usr/include/boost/regex/v4/basic_regex.hpp", 461, __PRETTY_FUNCTION__), 0)));
> return m_pimpl->get_restart_type();
> }
> const unsigned char* get_map()const
> {
> (static_cast<void> ((0 != m_pimpl.get()) ? 0 : (__assert_fail ("0 != m_pimpl.get()", "/usr/include/boost/regex/v4/basic_regex.hpp", 466, __PRETTY_FUNCTION__), 0)));
> return m_pimpl->get_map();
> }
> const ::boost::regex_traits_wrapper<traits>& get_traits()const
> {
> (static_cast<void> ((0 != m_pimpl.get()) ? 0 : (__assert_fail ("0 != m_pimpl.get()", "/usr/include/boost/regex/v4/basic_regex.hpp", 471, __PRETTY_FUNCTION__), 0)));
> return m_pimpl->get_traits();
> }
> bool can_be_null()const
> {
> (static_cast<void> ((0 != m_pimpl.get()) ? 0 : (__assert_fail ("0 != m_pimpl.get()", "/usr/include/boost/regex/v4/basic_regex.hpp", 476, __PRETTY_FUNCTION__), 0)));
> return m_pimpl->can_be_null();
> }
> const re_detail::regex_data<charT, traits>& get_data()const
> {
> (static_cast<void> ((0 != m_pimpl.get()) ? 0 : (__assert_fail ("0 != m_pimpl.get()", "/usr/include/boost/regex/v4/basic_regex.hpp", 481, __PRETTY_FUNCTION__), 0)));
> return m_pimpl->get_data();
> }
>
>private:
> shared_ptr<re_detail::basic_regex_implementation<charT, traits> > m_pimpl;
>};
>
>
>
>
>
>
>
>template <class charT, class traits>
>basic_regex<charT, traits>& basic_regex<charT, traits>::assign(const charT* p1,
> const charT* p2,
> flag_type f)
>{
> shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp;
> if(!m_pimpl.get())
> {
> temp = shared_ptr<re_detail::basic_regex_implementation<charT, traits> >(new re_detail::basic_regex_implementation<charT, traits>());
> }
> else
> {
> temp = shared_ptr<re_detail::basic_regex_implementation<charT, traits> >(new re_detail::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
> }
> temp->assign(p1, p2, f);
> temp.swap(m_pimpl);
> return *this;
>}
>
>template <class charT, class traits>
>typename basic_regex<charT, traits>::locale_type basic_regex<charT, traits>::imbue(locale_type l)
>{
> shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp(new re_detail::basic_regex_implementation<charT, traits>());
> locale_type result = temp->imbue(l);
> temp.swap(m_pimpl);
> return result;
>}
>
>
>
>
>template <class charT, class traits>
>void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)
>{
> e1.swap(e2);
>}
>
>
>template <class charT, class traits, class traits2>
>std::basic_ostream<charT, traits>&
> operator << (std::basic_ostream<charT, traits>& os,
> const basic_regex<charT, traits2>& e)
>{
> return (os << e.str());
>}
># 556 "/usr/include/boost/regex/v4/basic_regex.hpp" 3 4
>template <class charT, class traits >
>
>class reg_expression : public basic_regex<charT, traits>
>{
>public:
> typedef typename basic_regex<charT, traits>::flag_type flag_type;
> typedef typename basic_regex<charT, traits>::size_type size_type;
> explicit reg_expression(){}
> explicit reg_expression(const charT* p, flag_type f = regex_constants::normal)
> : basic_regex<charT, traits>(p, f){}
> reg_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
> : basic_regex<charT, traits>(p1, p2, f){}
> reg_expression(const charT* p, size_type len, flag_type f)
> : basic_regex<charT, traits>(p, len, f){}
> reg_expression(const reg_expression& that)
> : basic_regex<charT, traits>(that) {}
> ~reg_expression(){}
> reg_expression& operator=(const reg_expression& that)
> {
> return this->assign(that);
> }
>
>
> template <class ST, class SA>
> explicit reg_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
> : basic_regex<charT, traits>(p, f)
> {
> }
>
> template <class InputIterator>
> reg_expression(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)
> : basic_regex<charT, traits>(arg_first, arg_last, f)
> {
> }
>
> template <class ST, class SA>
> reg_expression& operator=(const std::basic_string<charT, ST, SA>& p)
> {
> this->assign(p);
> return *this;
> }
># 610 "/usr/include/boost/regex/v4/basic_regex.hpp" 3 4
>};
>
>
>
>
>
>}
># 68 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/basic_regex_creator.hpp" 1 3 4
># 27 "/usr/include/boost/regex/v4/basic_regex_creator.hpp" 3 4
>namespace boost{
>
>namespace re_detail{
>
>template <class charT>
>struct digraph : public std::pair<charT, charT>
>{
> digraph() : std::pair<charT, charT>(0, 0){}
> digraph(charT c1) : std::pair<charT, charT>(c1, 0){}
> digraph(charT c1, charT c2) : std::pair<charT, charT>(c1, c2)
> {}
>
> digraph(const digraph<charT>& d) : std::pair<charT, charT>(d.first, d.second){}
>
> template <class Seq>
> digraph(const Seq& s) : std::pair<charT, charT>()
> {
> (static_cast<void> ((s.size() <= 2) ? 0 : (__assert_fail ("s.size() <= 2", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 44, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((s.size()) ? 0 : (__assert_fail ("s.size()", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 45, __PRETTY_FUNCTION__), 0)));
> this->first = s[0];
> this->second = (s.size() > 1) ? s[1] : 0;
> }
>};
>
>template <class charT, class traits>
>class basic_char_set
>{
>public:
> typedef digraph<charT> digraph_type;
> typedef typename traits::string_type string_type;
> typedef typename traits::char_class_type mask_type;
>
> basic_char_set()
> {
> m_negate = false;
> m_has_digraphs = false;
> m_classes = 0;
> m_empty = true;
> }
>
> void add_single(const digraph_type& s)
> {
> m_singles.insert(m_singles.end(), s);
> if(s.second)
> m_has_digraphs = true;
> m_empty = false;
> }
> void add_range(const digraph_type& first, const digraph_type& end)
> {
> m_ranges.insert(m_ranges.end(), first);
> m_ranges.insert(m_ranges.end(), end);
> if(first.second)
> {
> m_has_digraphs = true;
> add_single(first);
> }
> if(end.second)
> {
> m_has_digraphs = true;
> add_single(end);
> }
> m_empty = false;
> }
> void add_class(mask_type m)
> {
> m_classes |= m;
> m_empty = false;
> }
> void add_equivalent(const digraph_type& s)
> {
> m_equivalents.insert(m_equivalents.end(), s);
> if(s.second)
> {
> m_has_digraphs = true;
> add_single(s);
> }
> m_empty = false;
> }
> void negate()
> {
> m_negate = true;
>
> }
>
>
>
>
> bool has_digraphs()const
> {
> return m_has_digraphs;
> }
> bool is_negated()const
> {
> return m_negate;
> }
> typedef typename std::vector<digraph_type>::const_iterator list_iterator;
> list_iterator singles_begin()const
> {
> return m_singles.begin();
> }
> list_iterator singles_end()const
> {
> return m_singles.end();
> }
> list_iterator ranges_begin()const
> {
> return m_ranges.begin();
> }
> list_iterator ranges_end()const
> {
> return m_ranges.end();
> }
> list_iterator equivalents_begin()const
> {
> return m_equivalents.begin();
> }
> list_iterator equivalents_end()const
> {
> return m_equivalents.end();
> }
> mask_type classes()const
> {
> return m_classes;
> }
> bool empty()const
> {
> return m_empty;
> }
>private:
> std::vector<digraph_type> m_singles;
> std::vector<digraph_type> m_ranges;
> bool m_negate;
> bool m_has_digraphs;
> mask_type m_classes;
> bool m_empty;
> std::vector<digraph_type> m_equivalents;
>};
>
>template <class charT, class traits>
>class basic_regex_creator
>{
>public:
> basic_regex_creator(regex_data<charT, traits>* data);
> std::ptrdiff_t getoffset(void* addr)
> {
> return getoffset(addr, m_pdata->m_data.data());
> }
> std::ptrdiff_t getoffset(const void* addr, const void* base)
> {
> return static_cast<const char*>(addr) - static_cast<const char*>(base);
> }
> re_syntax_base* getaddress(std::ptrdiff_t off)
> {
> return getaddress(off, m_pdata->m_data.data());
> }
> re_syntax_base* getaddress(std::ptrdiff_t off, void* base)
> {
> return static_cast<re_syntax_base*>(static_cast<void*>(static_cast<char*>(base) + off));
> }
> void init(unsigned flags)
> {
> m_pdata->m_flags = flags;
> m_icase = flags & regex_constants::icase;
> }
> regbase::flag_type flags()
> {
> return m_pdata->m_flags;
> }
> void flags(regbase::flag_type f)
> {
> m_pdata->m_flags = f;
> if(m_icase != static_cast<bool>(f & regbase::icase))
> {
> m_icase = static_cast<bool>(f & regbase::icase);
> }
> }
> re_syntax_base* append_state(syntax_element_type t, std::size_t s = sizeof(re_syntax_base));
> re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s = sizeof(re_syntax_base));
> re_literal* append_literal(charT c);
> re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set);
> re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set, mpl::false_*);
> re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set, mpl::true_*);
> void finalize(const charT* p1, const charT* p2);
>protected:
> regex_data<charT, traits>* m_pdata;
> const ::boost::regex_traits_wrapper<traits>&
> m_traits;
> re_syntax_base* m_last_state;
> bool m_icase;
> unsigned m_repeater_id;
> bool m_has_backrefs;
> unsigned m_backrefs;
> boost::uintmax_t m_bad_repeats;
> typename traits::char_class_type m_word_mask;
> typename traits::char_class_type m_mask_space;
> typename traits::char_class_type m_lower_mask;
> typename traits::char_class_type m_upper_mask;
> typename traits::char_class_type m_alpha_mask;
>private:
> basic_regex_creator& operator=(const basic_regex_creator&);
> basic_regex_creator(const basic_regex_creator&);
>
> void fixup_pointers(re_syntax_base* state);
> void create_startmaps(re_syntax_base* state);
> int calculate_backstep(re_syntax_base* state);
> void create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask);
> unsigned get_restart_type(re_syntax_base* state);
> void set_all_masks(unsigned char* bits, unsigned char);
> bool is_bad_repeat(re_syntax_base* pt);
> void set_bad_repeat(re_syntax_base* pt);
> syntax_element_type get_repeat_type(re_syntax_base* state);
> void probe_leading_repeat(re_syntax_base* state);
>};
>
>template <class charT, class traits>
>basic_regex_creator<charT, traits>::basic_regex_creator(regex_data<charT, traits>* data)
> : m_pdata(data), m_traits(*(data->m_ptraits)), m_last_state(0), m_repeater_id(0), m_has_backrefs(false), m_backrefs(0)
>{
> m_pdata->m_data.clear();
> m_pdata->m_status = ::boost::regex_constants::error_ok;
> static const charT w = 'w';
> static const charT s = 's';
> static const charT l[5] = { 'l', 'o', 'w', 'e', 'r', };
> static const charT u[5] = { 'u', 'p', 'p', 'e', 'r', };
> static const charT a[5] = { 'a', 'l', 'p', 'h', 'a', };
> m_word_mask = m_traits.lookup_classname(&w, &w +1);
> m_mask_space = m_traits.lookup_classname(&s, &s +1);
> m_lower_mask = m_traits.lookup_classname(l, l + 5);
> m_upper_mask = m_traits.lookup_classname(u, u + 5);
> m_alpha_mask = m_traits.lookup_classname(a, a + 5);
> (static_cast<void> ((m_word_mask != 0) ? 0 : (__assert_fail ("m_word_mask != 0", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 257, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((m_mask_space != 0) ? 0 : (__assert_fail ("m_mask_space != 0", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 258, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((m_lower_mask != 0) ? 0 : (__assert_fail ("m_lower_mask != 0", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 259, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((m_upper_mask != 0) ? 0 : (__assert_fail ("m_upper_mask != 0", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 260, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((m_alpha_mask != 0) ? 0 : (__assert_fail ("m_alpha_mask != 0", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 261, __PRETTY_FUNCTION__), 0)));
>}
>
>template <class charT, class traits>
>re_syntax_base* basic_regex_creator<charT, traits>::append_state(syntax_element_type t, std::size_t s)
>{
>
> if(t == syntax_element_backref)
> this->m_has_backrefs = true;
>
> m_pdata->m_data.align();
>
> if(m_last_state)
> m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state);
>
> m_last_state = static_cast<re_syntax_base*>(m_pdata->m_data.extend(s));
>
> m_last_state->next.i = 0;
> m_last_state->type = t;
> return m_last_state;
>}
>
>template <class charT, class traits>
>re_syntax_base* basic_regex_creator<charT, traits>::insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s)
>{
>
> m_pdata->m_data.align();
>
> if(m_last_state)
> m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state);
>
> std::ptrdiff_t off = getoffset(m_last_state) + s;
>
> re_syntax_base* new_state = static_cast<re_syntax_base*>(m_pdata->m_data.insert(pos, s));
>
> new_state->next.i = s;
> new_state->type = t;
> m_last_state = getaddress(off);
> return new_state;
>}
>
>template <class charT, class traits>
>re_literal* basic_regex_creator<charT, traits>::append_literal(charT c)
>{
> re_literal* result;
>
> if((0 == m_last_state) || (m_last_state->type != syntax_element_literal))
> {
>
> result = static_cast<re_literal*>(append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));
> result->length = 1;
> *static_cast<charT*>(static_cast<void*>(result+1)) = m_traits.translate(c, m_icase);
> }
> else
> {
>
> std::ptrdiff_t off = getoffset(m_last_state);
> m_pdata->m_data.extend(sizeof(charT));
> m_last_state = result = static_cast<re_literal*>(getaddress(off));
> charT* characters = static_cast<charT*>(static_cast<void*>(result+1));
> characters[result->length] = m_traits.translate(c, m_icase);
> ++(result->length);
> }
> return result;
>}
>
>template <class charT, class traits>
>inline re_syntax_base* basic_regex_creator<charT, traits>::append_set(
> const basic_char_set<charT, traits>& char_set)
>{
> typedef mpl::bool_< (sizeof(charT) == 1) > truth_type;
> return char_set.has_digraphs()
> ? append_set(char_set, static_cast<mpl::false_*>(0))
> : append_set(char_set, static_cast<truth_type*>(0));
>}
>
>template <class charT, class traits>
>re_syntax_base* basic_regex_creator<charT, traits>::append_set(
> const basic_char_set<charT, traits>& char_set, mpl::false_*)
>{
> typedef typename traits::string_type string_type;
> typedef typename basic_char_set<charT, traits>::list_iterator item_iterator;
> typedef typename traits::char_class_type mask_type;
>
> re_set_long<mask_type>* result = static_cast<re_set_long<mask_type>*>(append_state(syntax_element_long_set, sizeof(re_set_long<mask_type>)));
>
>
>
> result->csingles = static_cast<unsigned int>(::boost::re_detail::distance(char_set.singles_begin(), char_set.singles_end()));
> result->cranges = static_cast<unsigned int>(::boost::re_detail::distance(char_set.ranges_begin(), char_set.ranges_end())) / 2;
> result->cequivalents = static_cast<unsigned int>(::boost::re_detail::distance(char_set.equivalents_begin(), char_set.equivalents_end()));
> result->cclasses = char_set.classes();
> if(flags() & regbase::icase)
> {
>
> if(((result->cclasses & m_lower_mask) == m_lower_mask) || ((result->cclasses & m_upper_mask) == m_upper_mask))
> result->cclasses |= m_alpha_mask;
> }
>
> result->isnot = char_set.is_negated();
> result->singleton = !char_set.has_digraphs();
>
>
>
> std::ptrdiff_t offset = getoffset(result);
>
>
>
> item_iterator first, last;
> first = char_set.singles_begin();
> last = char_set.singles_end();
> while(first != last)
> {
> charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (first->second ? 3 : 2)));
> p[0] = m_traits.translate(first->first, m_icase);
> if(first->second)
> {
> p[1] = m_traits.translate(first->second, m_icase);
> p[2] = 0;
> }
> else
> p[1] = 0;
> ++first;
> }
>
>
>
> first = char_set.ranges_begin();
> last = char_set.ranges_end();
> while(first != last)
> {
>
> digraph<charT> c1 = *first;
> c1.first = this->m_traits.translate(c1.first, this->m_icase);
> c1.second = this->m_traits.translate(c1.second, this->m_icase);
> ++first;
> digraph<charT> c2 = *first;
> c2.first = this->m_traits.translate(c2.first, this->m_icase);
> c2.second = this->m_traits.translate(c2.second, this->m_icase);
> ++first;
> string_type s1, s2;
>
> if(flags() & regex_constants::collate)
> {
># 415 "/usr/include/boost/regex/v4/basic_regex_creator.hpp" 3 4
> charT a1[3] = { c1.first, c1.second, charT(0), };
> charT a2[3] = { c2.first, c2.second, charT(0), };
> s1 = this->m_traits.transform(a1, (a1[1] ? a1+2 : a1+1));
> s2 = this->m_traits.transform(a2, (a2[1] ? a2+2 : a2+1));
>
> if(s1.size() == 0)
> s1 = string_type(1, charT(0));
> if(s2.size() == 0)
> s2 = string_type(1, charT(0));
> }
> else
> {
> if(c1.second)
> {
> s1.insert(s1.end(), c1.first);
> s1.insert(s1.end(), c1.second);
> }
> else
> s1 = string_type(1, c1.first);
> if(c2.second)
> {
> s2.insert(s2.end(), c2.first);
> s2.insert(s2.end(), c2.second);
> }
> else
> s2.insert(s2.end(), c2.first);
> }
> if(s1 > s2)
> {
>
> return 0;
> }
> charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s1.size() + s2.size() + 2) ) );
> re_detail::copy(s1.begin(), s1.end(), p);
> p[s1.size()] = charT(0);
> p += s1.size() + 1;
> re_detail::copy(s2.begin(), s2.end(), p);
> p[s2.size()] = charT(0);
> }
>
>
>
> first = char_set.equivalents_begin();
> last = char_set.equivalents_end();
> while(first != last)
> {
> string_type s;
> if(first->second)
> {
>
>
>
>
>
>
> charT cs[3] = { first->first, first->second, charT(0), };
> s = m_traits.transform_primary(cs, cs+2);
>
> }
> else
> s = m_traits.transform_primary(&first->first, &first->first+1);
> if(s.empty())
> return 0;
> charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s.size()+1) ) );
> re_detail::copy(s.begin(), s.end(), p);
> p[s.size()] = charT(0);
> ++first;
> }
>
>
>
> m_last_state = result = static_cast<re_set_long<mask_type>*>(getaddress(offset));
> return result;
>}
>
>namespace{
>
>template<class T>
>inline bool char_less(T t1, T t2)
>{
> return t1 < t2;
>}
>template<>
>inline bool char_less<char>(char t1, char t2)
>{
> return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2);
>}
>template<>
>inline bool char_less<signed char>(signed char t1, signed char t2)
>{
> return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2);
>}
>}
>
>template <class charT, class traits>
>re_syntax_base* basic_regex_creator<charT, traits>::append_set(
> const basic_char_set<charT, traits>& char_set, mpl::true_*)
>{
> typedef typename traits::string_type string_type;
> typedef typename basic_char_set<charT, traits>::list_iterator item_iterator;
>
> re_set* result = static_cast<re_set*>(append_state(syntax_element_set, sizeof(re_set)));
> bool negate = char_set.is_negated();
> std::memset(result->_map, 0, sizeof(result->_map));
>
>
>
> item_iterator first, last;
> first = char_set.singles_begin();
> last = char_set.singles_end();
> while(first != last)
> {
> for(unsigned int i = 0; i < (1 << 8); ++i)
> {
> if(this->m_traits.translate(static_cast<charT>(i), this->m_icase)
> == this->m_traits.translate(first->first, this->m_icase))
> result->_map[i] = true;
> }
> ++first;
> }
>
>
>
> first = char_set.ranges_begin();
> last = char_set.ranges_end();
> while(first != last)
> {
>
> charT c1 = this->m_traits.translate(first->first, this->m_icase);
> ++first;
> charT c2 = this->m_traits.translate(first->first, this->m_icase);
> ++first;
>
> if(flags() & regex_constants::collate)
> {
>
> charT c3[2] = { c1, charT(0), };
> string_type s1 = this->m_traits.transform(c3, c3+1);
> c3[0] = c2;
> string_type s2 = this->m_traits.transform(c3, c3+1);
> if(s1 > s2)
> {
>
> return 0;
> }
> for(unsigned i = 0; i < (1u << 8); ++i)
> {
> charT c3[2] = { static_cast<charT>(i), charT(0), };
> string_type s3 = this->m_traits.transform(c3, c3 +1);
> if((s1 <= s3) && (s3 <= s2))
> result->_map[i] = true;
> }
> }
> else
> {
> if(char_less<charT>(c2, c1))
> {
>
> return 0;
> }
>
> std::memset(result->_map + static_cast<unsigned char>(c1), true, 1 + static_cast<unsigned char>(c2) - static_cast<unsigned char>(c1));
> }
> }
>
>
>
> typedef typename traits::char_class_type mask_type;
> mask_type m = char_set.classes();
> if(flags() & regbase::icase)
> {
>
> if(((m & m_lower_mask) == m_lower_mask) || ((m & m_upper_mask) == m_upper_mask))
> m |= m_alpha_mask;
> }
> if(m != 0)
> {
> for(unsigned i = 0; i < (1u << 8); ++i)
> {
> if(this->m_traits.isctype(static_cast<charT>(i), m))
> result->_map[i] = true;
> }
> }
>
>
>
> first = char_set.equivalents_begin();
> last = char_set.equivalents_end();
> while(first != last)
> {
> string_type s;
> (static_cast<void> ((static_cast<charT>(0) == first->second) ? 0 : (__assert_fail ("static_cast<charT>(0) == first->second", "/usr/include/boost/regex/v4/basic_regex_creator.hpp", 606, __PRETTY_FUNCTION__), 0)));
> s = m_traits.transform_primary(&first->first, &first->first+1);
> if(s.empty())
> return 0;
> for(unsigned i = 0; i < (1u << 8); ++i)
> {
> charT c[2] = { (static_cast<charT>(i)), charT(0), };
> string_type s2 = this->m_traits.transform_primary(c, c+1);
> if(s == s2)
> result->_map[i] = true;
> }
> ++first;
> }
> if(negate)
> {
> for(unsigned i = 0; i < (1u << 8); ++i)
> {
> result->_map[i] = !(result->_map[i]);
> }
> }
> return result;
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::finalize(const charT* p1, const charT* p2)
>{
>
>
> append_state(syntax_element_match);
>
> std::ptrdiff_t len = p2 - p1;
> m_pdata->m_expression_len = len;
> charT* ps = static_cast<charT*>(m_pdata->m_data.extend(sizeof(charT) * (1 + (p2 - p1))));
> m_pdata->m_expression = ps;
> re_detail::copy(p1, p2, ps);
> ps[p2 - p1] = 0;
>
>
> m_pdata->m_status = 0;
>
> m_pdata->m_first_state = static_cast<re_syntax_base*>(m_pdata->m_data.data());
>
> fixup_pointers(m_pdata->m_first_state);
>
> create_startmaps(m_pdata->m_first_state);
>
> std::memset(m_pdata->m_startmap, 0, sizeof(m_pdata->m_startmap));
> m_pdata->m_can_be_null = 0;
>
> m_bad_repeats = 0;
> create_startmap(m_pdata->m_first_state, m_pdata->m_startmap, &(m_pdata->m_can_be_null), mask_all);
>
> m_pdata->m_restart_type = get_restart_type(m_pdata->m_first_state);
>
> probe_leading_repeat(m_pdata->m_first_state);
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::fixup_pointers(re_syntax_base* state)
>{
> while(state)
> {
> switch(state->type)
> {
> case syntax_element_rep:
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
>
> static_cast<re_repeat*>(state)->id = m_repeater_id++;
>
> case syntax_element_alt:
> std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));
> static_cast<re_alt*>(state)->can_be_null = 0;
>
> case syntax_element_jump:
> static_cast<re_jump*>(state)->alt.p = getaddress(static_cast<re_jump*>(state)->alt.i, state);
>
> default:
> if(state->next.i)
> state->next.p = getaddress(state->next.i, state);
> else
> state->next.p = 0;
> }
> state = state->next.p;
> }
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::create_startmaps(re_syntax_base* state)
>{
># 706 "/usr/include/boost/regex/v4/basic_regex_creator.hpp" 3 4
> bool l_icase = m_icase;
> std::vector<std::pair<bool, re_syntax_base*> > v;
>
> while(state)
> {
> switch(state->type)
> {
> case syntax_element_toggle_case:
>
> m_icase = static_cast<re_case*>(state)->icase;
> state = state->next.p;
> continue;
> case syntax_element_alt:
> case syntax_element_rep:
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
>
> v.push_back(std::pair<bool, re_syntax_base*>(m_icase, state));
> state = state->next.p;
> break;
> case syntax_element_backstep:
>
> static_cast<re_brace*>(state)->index
> = this->calculate_backstep(state->next.p);
> if(static_cast<re_brace*>(state)->index < 0)
> {
>
> if(0 == this->m_pdata->m_status)
> this->m_pdata->m_status = boost::regex_constants::error_brack;
> if(0 == (this->flags() & regex_constants::no_except))
> {
> std::string message = this->m_pdata->m_ptraits->error_string(boost::regex_constants::error_brack);
> boost::regex_error e(message, boost::regex_constants::error_brack, 0);
> e.raise();
> }
> }
>
> default:
> state = state->next.p;
> }
> }
>
> while(v.size())
> {
> const std::pair<bool, re_syntax_base*>& p = v.back();
> m_icase = p.first;
> state = p.second;
> v.pop_back();
>
> create_startmap(state->next.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(state)->can_be_null, mask_take);
> m_bad_repeats = 0;
> create_startmap(static_cast<re_alt*>(state)->alt.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(state)->can_be_null, mask_skip);
>
> state->type = this->get_repeat_type(state);
> }
>
> m_icase = l_icase;
>}
>
>template <class charT, class traits>
>int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state)
>{
> typedef typename traits::char_class_type mask_type;
> int result = 0;
> while(state)
> {
> switch(state->type)
> {
> case syntax_element_startmark:
> if((static_cast<re_brace*>(state)->index == -1)
> || (static_cast<re_brace*>(state)->index == -2))
> {
> state = static_cast<re_jump*>(state->next.p)->alt.p->next.p;
> continue;
> }
> else if(static_cast<re_brace*>(state)->index == -3)
> {
> state = state->next.p->next.p;
> continue;
> }
> break;
> case syntax_element_endmark:
> if((static_cast<re_brace*>(state)->index == -1)
> || (static_cast<re_brace*>(state)->index == -2))
> return result;
> break;
> case syntax_element_literal:
> result += static_cast<re_literal*>(state)->length;
> break;
> case syntax_element_wild:
> case syntax_element_set:
> result += 1;
> break;
> case syntax_element_backref:
> case syntax_element_rep:
> case syntax_element_combining:
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
> case syntax_element_backstep:
> return -1;
> case syntax_element_long_set:
> if(static_cast<re_set_long<mask_type>*>(state)->singleton == 0)
> return -1;
> result += 1;
> break;
> case syntax_element_jump:
> state = static_cast<re_jump*>(state)->alt.p;
> continue;
> default:
> break;
> }
> state = state->next.p;
> }
> return -1;
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask)
>{
> int not_last_jump = 1;
>
>
> bool l_icase = m_icase;
>
> while(state)
> {
> switch(state->type)
> {
> case syntax_element_toggle_case:
> l_icase = static_cast<re_case*>(state)->icase;
> state = state->next.p;
> break;
> case syntax_element_literal:
> {
>
>
> if(l_map)
> {
> l_map[0] |= mask_init;
> charT first_char = *static_cast<charT*>(static_cast<void*>(static_cast<re_literal*>(state) + 1));
> for(unsigned int i = 0; i < (1u << 8); ++i)
> {
> if(m_traits.translate(static_cast<charT>(i), l_icase) == first_char)
> l_map[i] |= mask;
> }
> }
> return;
> }
> case syntax_element_end_line:
> {
>
> if(l_map)
> {
> l_map[0] |= mask_init;
> l_map['\n'] |= mask;
> l_map['\r'] |= mask;
> l_map['\f'] |= mask;
> l_map[0x85] |= mask;
> }
>
> if(pnull)
> create_startmap(state->next.p, 0, pnull, mask);
> return;
> }
> case syntax_element_backref:
>
> if(pnull)
> *pnull |= mask;
>
> case syntax_element_wild:
> {
>
> set_all_masks(l_map, mask);
> return;
> }
> case syntax_element_match:
> {
>
> set_all_masks(l_map, mask);
> if(pnull)
> *pnull |= mask;
> return;
> }
> case syntax_element_word_start:
> {
>
> create_startmap(state->next.p, l_map, pnull, mask);
> if(l_map)
> {
> l_map[0] |= mask_init;
> for(unsigned int i = 0; i < (1u << 8); ++i)
> {
> if(!m_traits.isctype(static_cast<charT>(i), m_word_mask))
> l_map[i] &= static_cast<unsigned char>(~mask);
> }
> }
> return;
> }
> case syntax_element_word_end:
> {
>
> create_startmap(state->next.p, l_map, pnull, mask);
> if(l_map)
> {
> l_map[0] |= mask_init;
> for(unsigned int i = 0; i < (1u << 8); ++i)
> {
> if(m_traits.isctype(static_cast<charT>(i), m_word_mask))
> l_map[i] &= static_cast<unsigned char>(~mask);
> }
> }
> return;
> }
> case syntax_element_buffer_end:
> {
>
> if(pnull)
> *pnull |= mask;
> return;
> }
> case syntax_element_long_set:
> if(l_map)
> {
> typedef typename traits::char_class_type mask_type;
> if(static_cast<re_set_long<mask_type>*>(state)->singleton)
> {
> l_map[0] |= mask_init;
> for(unsigned int i = 0; i < (1u << 8); ++i)
> {
> charT c = static_cast<charT>(i);
> if(&c != re_is_set_member(&c, &c + 1, static_cast<re_set_long<mask_type>*>(state), *m_pdata, m_icase))
> l_map[i] |= mask;
> }
> }
> else
> set_all_masks(l_map, mask);
> }
> return;
> case syntax_element_set:
> if(l_map)
> {
> l_map[0] |= mask_init;
> for(unsigned int i = 0; i < (1u << 8); ++i)
> {
> if(static_cast<re_set*>(state)->_map[
> static_cast<unsigned char>(m_traits.translate(static_cast<charT>(i), l_icase))])
> l_map[i] |= mask;
> }
> }
> return;
> case syntax_element_jump:
>
> state = static_cast<re_alt*>(state)->alt.p;
> not_last_jump = -1;
> break;
> case syntax_element_alt:
> case syntax_element_rep:
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
> {
> re_alt* rep = static_cast<re_alt*>(state);
> if(rep->_map[0] & mask_init)
> {
> if(l_map)
> {
>
> l_map[0] |= mask_init;
> for(unsigned int i = 0; i <= (127 * 2 + 1); ++i)
> {
> if(rep->_map[i] & mask_any)
> l_map[i] |= mask;
> }
> }
> if(pnull)
> {
> if(rep->can_be_null & mask_any)
> *pnull |= mask;
> }
> }
> else
> {
>
>
> if(is_bad_repeat(state))
> {
> set_all_masks(l_map, mask);
> return;
> }
> set_bad_repeat(state);
> create_startmap(state->next.p, l_map, pnull, mask);
> if((state->type == syntax_element_alt)
> || (static_cast<re_repeat*>(state)->min == 0)
> || (not_last_jump == 0))
> create_startmap(rep->alt.p, l_map, pnull, mask);
> }
> }
> return;
> case syntax_element_soft_buffer_end:
>
> if(l_map)
> {
> l_map[0] |= mask_init;
> l_map['\n'] |= mask;
> l_map['\r'] |= mask;
> }
> if(pnull)
> *pnull |= mask;
> return;
> case syntax_element_endmark:
>
> if(static_cast<re_brace*>(state)->index == -3)
> {
>
> set_all_masks(l_map, mask);
> if(pnull)
> *pnull |= mask;
> return;
> }
> else
> {
> state = state->next.p;
> break;
> }
>
> case syntax_element_startmark:
>
> if(static_cast<re_brace*>(state)->index == -3)
> {
> state = state->next.p->next.p;
> break;
> }
>
> default:
> state = state->next.p;
> }
> ++not_last_jump;
> }
>}
>
>template <class charT, class traits>
>unsigned basic_regex_creator<charT, traits>::get_restart_type(re_syntax_base* state)
>{
>
>
>
> while(state)
> {
> switch(state->type)
> {
> case syntax_element_startmark:
> case syntax_element_endmark:
> state = state->next.p;
> continue;
> case syntax_element_start_line:
> return regbase::restart_line;
> case syntax_element_word_start:
> return regbase::restart_word;
> case syntax_element_buffer_start:
> return regbase::restart_buf;
> case syntax_element_restart_continue:
> return regbase::restart_continue;
> default:
> state = 0;
> continue;
> }
> }
> return regbase::restart_any;
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::set_all_masks(unsigned char* bits, unsigned char mask)
>{
>
>
>
>
>
> if(bits)
> {
> if(bits[0] == 0)
> (std::memset)(bits, mask, 1u << 8);
> else
> {
> for(unsigned i = 0; i < (1u << 8); ++i)
> bits[i] |= mask;
> }
> bits[0] |= mask_init;
> }
>}
>
>template <class charT, class traits>
>bool basic_regex_creator<charT, traits>::is_bad_repeat(re_syntax_base* pt)
>{
> switch(pt->type)
> {
> case syntax_element_rep:
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
> {
> unsigned id = static_cast<re_repeat*>(pt)->id;
> if(id > sizeof(m_bad_repeats) * 8)
> return true;
> return m_bad_repeats & static_cast<boost::uintmax_t>(1uL << id);
> }
> default:
> return false;
> }
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::set_bad_repeat(re_syntax_base* pt)
>{
> switch(pt->type)
> {
> case syntax_element_rep:
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
> {
> unsigned id = static_cast<re_repeat*>(pt)->id;
> if(id <= sizeof(m_bad_repeats) * 8)
> m_bad_repeats |= static_cast<boost::uintmax_t>(1uL << id);
> }
> default:
> break;
> }
>}
>
>template <class charT, class traits>
>syntax_element_type basic_regex_creator<charT, traits>::get_repeat_type(re_syntax_base* state)
>{
> typedef typename traits::char_class_type mask_type;
> if(state->type == syntax_element_rep)
> {
>
> if(state->next.p->next.p->next.p == static_cast<re_alt*>(state)->alt.p)
> {
> switch(state->next.p->type)
> {
> case re_detail::syntax_element_wild:
> return re_detail::syntax_element_dot_rep;
> case re_detail::syntax_element_literal:
> return re_detail::syntax_element_char_rep;
> case re_detail::syntax_element_set:
> return re_detail::syntax_element_short_set_rep;
> case re_detail::syntax_element_long_set:
> if(static_cast<re_detail::re_set_long<mask_type>*>(state->next.p)->singleton)
> return re_detail::syntax_element_long_set_rep;
> break;
> default:
> break;
> }
> }
> }
> return state->type;
>}
>
>template <class charT, class traits>
>void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* state)
>{
>
>
> do
> {
> switch(state->type)
> {
> case syntax_element_startmark:
> if(static_cast<re_brace*>(state)->index >= 0)
> {
> state = state->next.p;
> continue;
> }
> return;
> case syntax_element_endmark:
> case syntax_element_start_line:
> case syntax_element_end_line:
> case syntax_element_word_boundary:
> case syntax_element_within_word:
> case syntax_element_word_start:
> case syntax_element_word_end:
> case syntax_element_buffer_start:
> case syntax_element_buffer_end:
> case syntax_element_restart_continue:
> state = state->next.p;
> break;
> case syntax_element_dot_rep:
> case syntax_element_char_rep:
> case syntax_element_short_set_rep:
> case syntax_element_long_set_rep:
> if(this->m_has_backrefs == 0)
> static_cast<re_repeat*>(state)->leading = true;
>
> default:
> return;
> }
> }while(state);
>}
>
>
>}
>
>}
># 71 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/basic_regex_parser.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/basic_regex_parser.hpp" 3 4
>namespace boost{
>namespace re_detail{
>
>
>
>
>
>
>template <class charT, class traits>
>class basic_regex_parser : public basic_regex_creator<charT, traits>
>{
>public:
> basic_regex_parser(regex_data<charT, traits>* data);
> void parse(const charT* p1, const charT* p2, unsigned flags);
> void fail(regex_constants::error_type error_code, std::ptrdiff_t position);
>
> bool parse_all();
> bool parse_basic();
> bool parse_extended();
> bool parse_literal();
> bool parse_open_paren();
> bool parse_basic_escape();
> bool parse_extended_escape();
> bool parse_match_any();
> bool parse_repeat(std::size_t low = 0, std::size_t high = (std::numeric_limits<std::size_t>::max)());
> bool parse_repeat_range(bool isbasic);
> bool parse_alt();
> bool parse_set();
> bool parse_backref();
> void parse_set_literal(basic_char_set<charT, traits>& char_set);
> bool parse_inner_set(basic_char_set<charT, traits>& char_set);
> bool parse_QE();
> bool parse_perl_extension();
> bool add_emacs_code(bool negate);
> bool unwind_alts(std::ptrdiff_t last_paren_start);
> digraph<charT> get_next_set_literal(basic_char_set<charT, traits>& char_set);
> charT unescape_character();
> regex_constants::syntax_option_type parse_options();
>
>private:
> typedef bool (basic_regex_parser::*parser_proc_type)();
> typedef typename traits::string_type string_type;
> typedef typename traits::char_class_type char_class_type;
> parser_proc_type m_parser_proc;
> const charT* m_base;
> const charT* m_end;
> const charT* m_position;
> unsigned m_mark_count;
> std::ptrdiff_t m_paren_start;
> std::ptrdiff_t m_alt_insert_point;
> bool m_has_case_change;
>
>
>
>
>
>
> std::vector<std::ptrdiff_t> m_alt_jumps;
>
>
> basic_regex_parser& operator=(const basic_regex_parser&);
> basic_regex_parser(const basic_regex_parser&);
>};
>
>template <class charT, class traits>
>basic_regex_parser<charT, traits>::basic_regex_parser(regex_data<charT, traits>* data)
> : basic_regex_creator<charT, traits>(data), m_mark_count(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false)
>{
>}
>
>template <class charT, class traits>
>void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2, unsigned flags)
>{
>
> this->init(flags);
>
> m_position = m_base = p1;
> m_end = p2;
>
> if(p1 == p2)
> {
> fail(regex_constants::error_empty, 0);
> return;
> }
>
> switch(flags & regbase::main_option_type)
> {
> case regbase::perl_syntax_group:
> m_parser_proc = &basic_regex_parser<charT, traits>::parse_extended;
> break;
> case regbase::basic_syntax_group:
> m_parser_proc = &basic_regex_parser<charT, traits>::parse_basic;
> break;
> case regbase::literal:
> m_parser_proc = &basic_regex_parser<charT, traits>::parse_literal;
> break;
> }
>
>
> bool result = parse_all();
>
>
>
> unwind_alts(-1);
>
> this->flags(flags);
>
>
> if(!result)
> {
> fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_position));
> return;
> }
>
> if(this->m_pdata->m_status)
> return;
>
> this->m_pdata->m_mark_count = 1 + m_mark_count;
> this->finalize(p1, p2);
>}
>
>template <class charT, class traits>
>void basic_regex_parser<charT, traits>::fail(regex_constants::error_type error_code, std::ptrdiff_t position)
>{
> if(0 == this->m_pdata->m_status)
> this->m_pdata->m_status = error_code;
> m_position = m_end;
>
> std::string message = this->m_pdata->m_ptraits->error_string(error_code);
>
>
> if(0 == (this->flags() & regex_constants::no_except))
> {
> boost::regex_error e(message, error_code, position);
> e.raise();
> }
>
>
>
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_all()
>{
> bool result = true;
> while(result && (m_position != m_end))
> {
> result = (this->*m_parser_proc)();
> }
> return result;
>}
>
>
>
>
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_basic()
>{
> switch(this->m_traits.syntax_type(*m_position))
> {
> case regex_constants::syntax_escape:
> return parse_basic_escape();
> case regex_constants::syntax_dot:
> return parse_match_any();
> case regex_constants::syntax_caret:
> ++m_position;
> this->append_state(syntax_element_start_line);
> break;
> case regex_constants::syntax_dollar:
> ++m_position;
> this->append_state(syntax_element_end_line);
> break;
> case regex_constants::syntax_star:
> if(!(this->m_last_state) || (this->m_last_state->type == syntax_element_start_line))
> return parse_literal();
> else
> {
> ++m_position;
> return parse_repeat();
> }
> case regex_constants::syntax_plus:
> if(!(this->m_last_state) || (this->m_last_state->type == syntax_element_start_line) || !(this->flags() & regbase::emacs_ex))
> return parse_literal();
> else
> {
> ++m_position;
> return parse_repeat(1);
> }
> case regex_constants::syntax_question:
> if(!(this->m_last_state) || (this->m_last_state->type == syntax_element_start_line) || !(this->flags() & regbase::emacs_ex))
> return parse_literal();
> else
> {
> ++m_position;
> return parse_repeat(0, 1);
> }
> case regex_constants::syntax_open_set:
> return parse_set();
> default:
> return parse_literal();
> }
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_extended()
>{
> bool result = true;
> switch(this->m_traits.syntax_type(*m_position))
> {
> case regex_constants::syntax_open_mark:
> return parse_open_paren();
> case regex_constants::syntax_close_mark:
> return false;
> case regex_constants::syntax_escape:
> return parse_extended_escape();
> case regex_constants::syntax_dot:
> return parse_match_any();
> case regex_constants::syntax_caret:
> ++m_position;
> this->append_state(
> (this->flags() & regex_constants::no_mod_m ? syntax_element_buffer_start : syntax_element_start_line));
> break;
> case regex_constants::syntax_dollar:
> ++m_position;
> this->append_state(
> (this->flags() & regex_constants::no_mod_m ? syntax_element_buffer_end : syntax_element_end_line));
> break;
> case regex_constants::syntax_star:
> if(m_position == this->m_base)
> {
> fail(regex_constants::error_badrepeat, 0);
> return false;
> }
> ++m_position;
> return parse_repeat();
> case regex_constants::syntax_question:
> if(m_position == this->m_base)
> {
> fail(regex_constants::error_badrepeat, 0);
> return false;
> }
> ++m_position;
> return parse_repeat(0,1);
> case regex_constants::syntax_plus:
> if(m_position == this->m_base)
> {
> fail(regex_constants::error_badrepeat, 0);
> return false;
> }
> ++m_position;
> return parse_repeat(1);
> case regex_constants::syntax_open_brace:
> ++m_position;
> return parse_repeat_range(false);
> case regex_constants::syntax_close_brace:
> fail(regex_constants::error_brace, this->m_position - this->m_end);
> return false;
> case regex_constants::syntax_or:
> return parse_alt();
> case regex_constants::syntax_open_set:
> return parse_set();
> case regex_constants::syntax_hash:
>
>
>
>
> if((this->flags()
> & (regbase::no_perl_ex|regbase::mod_x))
> == regbase::mod_x)
> {
> while((m_position != m_end) && !is_separator(*m_position++)){}
> return true;
> }
>
> default:
> result = parse_literal();
> break;
> }
> return result;
>}
>
>
>
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_literal()
>{
>
>
> if(
> ((this->flags()
> & (regbase::main_option_type|regbase::mod_x|regbase::no_perl_ex))
> != regbase::mod_x)
> || !this->m_traits.isctype(*m_position, this->m_mask_space))
> this->append_literal(*m_position);
> ++m_position;
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_open_paren()
>{
>
>
>
> if(++m_position == m_end)
> {
> fail(regex_constants::error_paren, m_position - m_base);
> return false;
> }
>
>
>
> if(
> ((this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) == 0)
> || ((this->flags() & (regbase::main_option_type | regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex))
> )
> {
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)
> return parse_perl_extension();
> }
>
>
>
> unsigned markid = 0;
> if(0 == (this->flags() & regbase::nosubs))
> markid = ++m_mark_count;
> re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));
> pb->index = markid;
> std::ptrdiff_t last_paren_start = this->getoffset(pb);
>
> std::ptrdiff_t last_alt_point = m_alt_insert_point;
> this->m_pdata->m_data.align();
> m_alt_insert_point = this->m_pdata->m_data.size();
>
>
>
> regex_constants::syntax_option_type opts = this->flags();
> bool old_case_change = m_has_case_change;
> m_has_case_change = false;
>
>
>
>
> parse_all();
>
>
>
> if(0 == unwind_alts(last_paren_start))
> return false;
>
>
>
> if(m_has_case_change)
> {
>
>
>
> static_cast<re_case*>(
> this->append_state(syntax_element_toggle_case, sizeof(re_case))
> )->icase = opts & regbase::icase;
> }
> this->flags(opts);
> m_has_case_change = old_case_change;
>
>
>
> if(m_position == m_end)
> {
> this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
> return false;
> }
> (static_cast<void> ((this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark) ? 0 : (__assert_fail ("this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark", "/usr/include/boost/regex/v4/basic_regex_parser.hpp", 400, __PRETTY_FUNCTION__), 0)));
> ++m_position;
>
>
>
> pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));
> pb->index = markid;
> this->m_paren_start = last_paren_start;
>
>
>
> this->m_alt_insert_point = last_alt_point;
>
>
>
> if((markid > 0) && (markid < sizeof(unsigned) * 8))
> this->m_backrefs |= 1u << (markid - 1);
>
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_basic_escape()
>{
> ++m_position;
> bool result = true;
> switch(this->m_traits.escape_syntax_type(*m_position))
> {
> case regex_constants::syntax_open_mark:
> return parse_open_paren();
> case regex_constants::syntax_close_mark:
> return false;
> case regex_constants::syntax_plus:
> if(this->flags() & regex_constants::bk_plus_qm)
> {
> ++m_position;
> return parse_repeat(1);
> }
> else
> return parse_literal();
> case regex_constants::syntax_question:
> if(this->flags() & regex_constants::bk_plus_qm)
> {
> ++m_position;
> return parse_repeat(0, 1);
> }
> else
> return parse_literal();
> case regex_constants::syntax_open_brace:
> if(this->flags() & regbase::no_intervals)
> return parse_literal();
> ++m_position;
> return parse_repeat_range(true);
> case regex_constants::syntax_close_brace:
> if(this->flags() & regbase::no_intervals)
> return parse_literal();
> fail(regex_constants::error_brace, this->m_position - this->m_base);
> return false;
> case regex_constants::syntax_or:
> if(this->flags() & regbase::bk_vbar)
> return parse_alt();
> else
> result = parse_literal();
> break;
> case regex_constants::syntax_digit:
> return parse_backref();
> case regex_constants::escape_type_start_buffer:
> if(this->flags() & regbase::emacs_ex)
> {
> ++m_position;
> this->append_state(syntax_element_buffer_start);
> }
> else
> result = parse_literal();
> break;
> case regex_constants::escape_type_end_buffer:
> if(this->flags() & regbase::emacs_ex)
> {
> ++m_position;
> this->append_state(syntax_element_buffer_end);
> }
> else
> result = parse_literal();
> break;
> case regex_constants::escape_type_word_assert:
> if(this->flags() & regbase::emacs_ex)
> {
> ++m_position;
> this->append_state(syntax_element_word_boundary);
> }
> else
> result = parse_literal();
> break;
> case regex_constants::escape_type_not_word_assert:
> if(this->flags() & regbase::emacs_ex)
> {
> ++m_position;
> this->append_state(syntax_element_within_word);
> }
> else
> result = parse_literal();
> break;
> case regex_constants::escape_type_left_word:
> if(this->flags() & regbase::emacs_ex)
> {
> ++m_position;
> this->append_state(syntax_element_word_start);
> }
> else
> result = parse_literal();
> break;
> case regex_constants::escape_type_right_word:
> if(this->flags() & regbase::emacs_ex)
> {
> ++m_position;
> this->append_state(syntax_element_word_end);
> }
> else
> result = parse_literal();
> break;
> default:
> if(this->flags() & regbase::emacs_ex)
> {
> bool negate = true;
> switch(*m_position)
> {
> case 'w':
> negate = false;
>
> case 'W':
> {
> basic_char_set<charT, traits> char_set;
> if(negate)
> char_set.negate();
> char_set.add_class(this->m_word_mask);
> if(0 == this->append_set(char_set))
> {
> fail(regex_constants::error_ctype, m_position - m_base);
> return false;
> }
> ++m_position;
> return true;
> }
> case 's':
> negate = false;
>
> case 'S':
> return add_emacs_code(negate);
> case 'c':
> case 'C':
>
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> default:
> break;
> }
> }
> result = parse_literal();
> break;
> }
> return result;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_extended_escape()
>{
> ++m_position;
> bool negate = false;
> switch(this->m_traits.escape_syntax_type(*m_position))
> {
> case regex_constants::escape_type_not_class:
> negate = true;
>
> case regex_constants::escape_type_class:
> {
> typedef typename traits::char_class_type mask_type;
> mask_type m = this->m_traits.lookup_classname(m_position, m_position+1);
> if(m != 0)
> {
> basic_char_set<charT, traits> char_set;
> if(negate)
> char_set.negate();
> char_set.add_class(m);
> if(0 == this->append_set(char_set))
> {
> fail(regex_constants::error_ctype, m_position - m_base);
> return false;
> }
> ++m_position;
> return true;
> }
>
>
>
> this->append_literal(unescape_character());
> break;
> }
> case regex_constants::syntax_digit:
> return parse_backref();
> case regex_constants::escape_type_left_word:
> ++m_position;
> this->append_state(syntax_element_word_start);
> break;
> case regex_constants::escape_type_right_word:
> ++m_position;
> this->append_state(syntax_element_word_end);
> break;
> case regex_constants::escape_type_start_buffer:
> ++m_position;
> this->append_state(syntax_element_buffer_start);
> break;
> case regex_constants::escape_type_end_buffer:
> ++m_position;
> this->append_state(syntax_element_buffer_end);
> break;
> case regex_constants::escape_type_word_assert:
> ++m_position;
> this->append_state(syntax_element_word_boundary);
> break;
> case regex_constants::escape_type_not_word_assert:
> ++m_position;
> this->append_state(syntax_element_within_word);
> break;
> case regex_constants::escape_type_Z:
> ++m_position;
> this->append_state(syntax_element_soft_buffer_end);
> break;
> case regex_constants::escape_type_Q:
> return parse_QE();
> case regex_constants::escape_type_C:
> return parse_match_any();
> case regex_constants::escape_type_X:
> ++m_position;
> this->append_state(syntax_element_combining);
> break;
> case regex_constants::escape_type_G:
> ++m_position;
> this->append_state(syntax_element_restart_continue);
> break;
> case regex_constants::escape_type_not_property:
> negate = true;
>
> case regex_constants::escape_type_property:
> {
> ++m_position;
> char_class_type m;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
>
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)
> {
> const charT* base = m_position;
>
> while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
> m = this->m_traits.lookup_classname(++base, m_position++);
> }
> else
> {
> m = this->m_traits.lookup_classname(m_position, m_position+1);
> ++m_position;
> }
> if(m != 0)
> {
> basic_char_set<charT, traits> char_set;
> if(negate)
> char_set.negate();
> char_set.add_class(m);
> if(0 == this->append_set(char_set))
> {
> fail(regex_constants::error_ctype, m_position - m_base);
> return false;
> }
> return true;
> }
> fail(regex_constants::error_ctype, m_position - m_base);
> }
> default:
> this->append_literal(unescape_character());
> break;
> }
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_match_any()
>{
>
>
>
> ++m_position;
> static_cast<re_dot*>(
> this->append_state(syntax_element_wild, sizeof(re_dot))
> )->mask = static_cast<unsigned char>(this->flags() & regbase::no_mod_s
> ? re_detail::force_not_newline
> : this->flags() & regbase::mod_s ?
> re_detail::force_newline : re_detail::dont_care);
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_t high)
>{
> bool greedy = true;
> std::size_t insert_point;
>
>
>
> if((m_position != m_end)
> && (
> (0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex)))
> || ((regbase::basic_syntax_group|regbase::emacs_ex) == (this->flags() & (regbase::main_option_type | regbase::emacs_ex)))
> )
> )
> {
>
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)
> {
> greedy = false;
> ++m_position;
> }
> }
> if(0 == this->m_last_state)
> {
> fail(regex_constants::error_badrepeat, ::boost::re_detail::distance(m_base, m_position));
> return false;
> }
> if(this->m_last_state->type == syntax_element_endmark)
> {
>
> insert_point = this->m_paren_start;
> }
> else if((this->m_last_state->type == syntax_element_literal) && (static_cast<re_literal*>(this->m_last_state)->length > 1))
> {
>
> re_literal* lit = static_cast<re_literal*>(this->m_last_state);
> charT c = (static_cast<charT*>(static_cast<void*>(lit+1)))[lit->length - 1];
> --(lit->length);
>
> lit = static_cast<re_literal*>(this->append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));
> lit->length = 1;
> (static_cast<charT*>(static_cast<void*>(lit+1)))[0] = c;
> insert_point = this->getoffset(this->m_last_state);
> }
> else
> {
>
> switch(this->m_last_state->type)
> {
> case syntax_element_start_line:
> case syntax_element_end_line:
> case syntax_element_word_boundary:
> case syntax_element_within_word:
> case syntax_element_word_start:
> case syntax_element_word_end:
> case syntax_element_buffer_start:
> case syntax_element_buffer_end:
> case syntax_element_alt:
> case syntax_element_soft_buffer_end:
> case syntax_element_restart_continue:
> case syntax_element_jump:
>
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> default:
>
> break;
> }
> insert_point = this->getoffset(this->m_last_state);
> }
>
>
>
> re_repeat* rep = static_cast<re_repeat*>(this->insert_state(insert_point, syntax_element_rep, re_repeater_size));
> rep->min = low;
> rep->max = high;
> rep->greedy = greedy;
> rep->leading = false;
>
> std::ptrdiff_t rep_off = this->getoffset(rep);
>
> re_jump* jmp = static_cast<re_jump*>(this->append_state(syntax_element_jump, sizeof(re_jump)));
> jmp->alt.i = rep_off - this->getoffset(jmp);
> this->m_pdata->m_data.align();
>
> rep = static_cast<re_repeat*>(this->getaddress(rep_off));
> rep->alt.i = this->m_pdata->m_data.size() - rep_off;
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_repeat_range(bool isbasic)
>{
>
>
>
> std::size_t min, max;
> int v;
>
> while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))
> ++m_position;
>
> if(this->m_position == this->m_end)
> {
> fail(regex_constants::error_brace, this->m_position - this->m_base);
> return false;
> }
>
> v = this->m_traits.toi(m_position, m_end, 10);
>
> while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))
> ++m_position;
> if(v < 0)
> {
> fail(regex_constants::error_badbrace, this->m_position - this->m_base);
> return false;
> }
> else if(this->m_position == this->m_end)
> {
> fail(regex_constants::error_brace, this->m_position - this->m_base);
> return false;
> }
> min = v;
>
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_comma)
> {
>
> ++m_position;
>
> while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))
> ++m_position;
> if(this->m_position == this->m_end)
> {
> fail(regex_constants::error_brace, this->m_position - this->m_base);
> return false;
> }
>
> v = this->m_traits.toi(m_position, m_end, 10);
> max = (v >= 0) ? v : (std::numeric_limits<std::size_t>::max)();
> }
> else
> {
>
> max = min;
> }
>
> while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))
> ++m_position;
>
> if(this->m_position == this->m_end)
> {
> fail(regex_constants::error_brace, this->m_position - this->m_base);
> return false;
> }
> if(isbasic)
> {
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_escape)
> {
> ++m_position;
> if(this->m_position == this->m_end)
> {
> fail(regex_constants::error_brace, this->m_position - this->m_base);
> return false;
> }
> }
> else
> {
> fail(regex_constants::error_badbrace, this->m_position - this->m_base);
> return false;
> }
> }
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_brace)
> ++m_position;
> else
> {
> fail(regex_constants::error_badbrace, this->m_position - this->m_base);
> return false;
> }
>
>
>
> if(min > max)
> {
> fail(regex_constants::error_range, this->m_position - this->m_base);
> return false;
> }
> return parse_repeat(min, max);
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_alt()
>{
>
>
>
>
> if((this->m_last_state == 0) || (this->m_last_state->type == syntax_element_startmark))
> {
> fail(regex_constants::error_empty, this->m_position - this->m_base);
> return false;
> }
> ++m_position;
>
>
>
> re_syntax_base* pj = this->append_state(re_detail::syntax_element_jump, sizeof(re_jump));
> std::ptrdiff_t jump_offset = this->getoffset(pj);
>
>
>
> re_alt* palt = static_cast<re_alt*>(this->insert_state(this->m_alt_insert_point, syntax_element_alt, re_alt_size));
> jump_offset += re_alt_size;
> this->m_pdata->m_data.align();
> palt->alt.i = this->m_pdata->m_data.size() - this->getoffset(palt);
>
>
>
>
> this->m_alt_insert_point = this->m_pdata->m_data.size();
>
>
>
>
> if(m_has_case_change)
> {
> static_cast<re_case*>(
> this->append_state(syntax_element_toggle_case, sizeof(re_case))
> )->icase = this->m_icase;
> }
>
>
>
>
>
>
> m_alt_jumps.push_back(jump_offset);
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_set()
>{
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> basic_char_set<charT, traits> char_set;
>
> const charT* base = m_position;
> const charT* item_base = m_position;
>
> while(m_position != m_end)
> {
> switch(this->m_traits.syntax_type(*m_position))
> {
> case regex_constants::syntax_caret:
> if(m_position == base)
> {
> char_set.negate();
> ++m_position;
> item_base = m_position;
> }
> else
> parse_set_literal(char_set);
> break;
> case regex_constants::syntax_close_set:
> if(m_position == item_base)
> {
> parse_set_literal(char_set);
> break;
> }
> else
> {
> ++m_position;
> if(0 == this->append_set(char_set))
> {
> fail(regex_constants::error_range, m_position - m_base);
> return false;
> }
> }
> return true;
> case regex_constants::syntax_open_set:
> if(parse_inner_set(char_set))
> break;
> return true;
> case regex_constants::syntax_escape:
> {
>
>
>
>
> ++m_position;
> if(this->m_traits.escape_syntax_type(*m_position)
> == regex_constants::escape_type_class)
> {
> char_class_type m = this->m_traits.lookup_classname(m_position, m_position+1);
> if(m != 0)
> {
> char_set.add_class(m);
> ++m_position;
> break;
> }
> }
> else if(this->m_traits.escape_syntax_type(*m_position)
> == regex_constants::escape_type_not_class)
> {
>
> char_class_type m = this->m_traits.lookup_classname(m_position, m_position+1);
> if(m != 0)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
> }
>
> --m_position;
> parse_set_literal(char_set);
> break;
> }
> default:
> parse_set_literal(char_set);
> break;
> }
> }
> return m_position != m_end;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_inner_set(basic_char_set<charT, traits>& char_set)
>{
>
>
>
>
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> switch(this->m_traits.syntax_type(*m_position))
> {
> case regex_constants::syntax_dot:
>
>
>
> --m_position;
> parse_set_literal(char_set);
> return true;
> case regex_constants::syntax_colon:
> {
>
> if((this->flags() & (regbase::main_option_type | regbase::no_char_classes))
> == (regbase::basic_syntax_group | regbase::no_char_classes))
> {
> --m_position;
> parse_set_literal(char_set);
> return true;
> }
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> const charT* name_first = m_position;
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> while((m_position != m_end)
> && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_colon))
> ++m_position;
> const charT* name_last = m_position;
> if(m_end == m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> if((m_end == ++m_position)
> || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> typedef typename traits::char_class_type mask_type;
> mask_type m = this->m_traits.lookup_classname(name_first, name_last);
> if(m == 0)
> {
> if(char_set.empty() && (name_last - name_first == 1))
> {
>
> ++m_position;
> if( (m_position != m_end)
> && (this->m_traits.syntax_type(*m_position)
> == regex_constants::syntax_close_set))
> {
> if(this->m_traits.escape_syntax_type(*name_first)
> == regex_constants::escape_type_left_word)
> {
> ++m_position;
> this->append_state(syntax_element_word_start);
> return false;
> }
> if(this->m_traits.escape_syntax_type(*name_first)
> == regex_constants::escape_type_right_word)
> {
> ++m_position;
> this->append_state(syntax_element_word_end);
> return false;
> }
> }
> }
> fail(regex_constants::error_ctype, name_first - m_base);
> return false;
> }
> char_set.add_class(m);
> ++m_position;
> break;
> }
> case regex_constants::syntax_equal:
> {
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> const charT* name_first = m_position;
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> while((m_position != m_end)
> && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal))
> ++m_position;
> const charT* name_last = m_position;
> if(m_end == m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> if((m_end == ++m_position)
> || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return false;
> }
> string_type m = this->m_traits.lookup_collatename(name_first, name_last);
> if((0 == m.size()) || (m.size() > 2))
> {
> fail(regex_constants::error_collate, name_first - m_base);
> return false;
> }
> digraph<charT> d;
> d.first = m[0];
> if(m.size() > 1)
> d.second = m[1];
> else
> d.second = 0;
> char_set.add_equivalent(d);
> ++m_position;
> break;
> }
> default:
> --m_position;
> parse_set_literal(char_set);
> break;
> }
> return true;
>}
>
>template <class charT, class traits>
>void basic_regex_parser<charT, traits>::parse_set_literal(basic_char_set<charT, traits>& char_set)
>{
> digraph<charT> start_range(get_next_set_literal(char_set));
> if(m_end == m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return;
> }
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_dash)
> {
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_brack, m_position - m_base);
> return;
> }
> if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set)
> {
> digraph<charT> end_range = get_next_set_literal(char_set);
> char_set.add_range(start_range, end_range);
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_dash)
> {
> fail(regex_constants::error_range, m_position - m_base);
> return;
> }
> return;
> }
> --m_position;
> }
> char_set.add_single(start_range);
>}
>
>template <class charT, class traits>
>digraph<charT> basic_regex_parser<charT, traits>::get_next_set_literal(basic_char_set<charT, traits>& char_set)
>{
> typedef typename traits::string_type string_type;
> digraph<charT> result;
> switch(this->m_traits.syntax_type(*m_position))
> {
> case regex_constants::syntax_dash:
> if(!char_set.empty())
> {
>
> if((++m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))
> {
> fail(regex_constants::error_range, m_position - m_base);
> return result;
> }
> --m_position;
> }
> result.first = *m_position++;
> return result;
> case regex_constants::syntax_escape:
>
> if(this->flags() & regex_constants::no_escape_in_lists)
> {
> result = *m_position++;
> break;
> }
> ++m_position;
> result = unescape_character();
> break;
> case regex_constants::syntax_open_set:
> {
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_collate, m_position - m_base);
> return result;
> }
> if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_dot)
> {
> --m_position;
> result.first = *m_position;
> ++m_position;
> return result;
> }
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_collate, m_position - m_base);
> return result;
> }
> const charT* name_first = m_position;
>
> if(m_end == ++m_position)
> {
> fail(regex_constants::error_collate, name_first - m_base);
> return result;
> }
> while((m_position != m_end)
> && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_dot))
> ++m_position;
> const charT* name_last = m_position;
> if(m_end == m_position)
> {
> fail(regex_constants::error_collate, name_first - m_base);
> return result;
> }
> if((m_end == ++m_position)
> || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))
> {
> fail(regex_constants::error_collate, name_first - m_base);
> return result;
> }
> ++m_position;
> string_type s = this->m_traits.lookup_collatename(name_first, name_last);
> if(s.empty() || (s.size() > 2))
> {
> fail(regex_constants::error_collate, name_first - m_base);
> return result;
> }
> result.first = s[0];
> if(s.size() > 1)
> result.second = s[1];
> else
> result.second = 0;
> return result;
> }
> default:
> result = *m_position++;
> }
> return result;
>}
>
>
>
>
>template <class charT>
>bool valid_value(charT, int v, const mpl::true_&)
>{
> return (v >> (sizeof(charT) * 8)) == 0;
>}
>template <class charT>
>bool valid_value(charT, int, const mpl::false_&)
>{
> return true;
>}
>template <class charT>
>bool valid_value(charT c, int v)
>{
> return valid_value(c, v, mpl::bool_<(sizeof(charT) < sizeof(int))>());
>}
>
>template <class charT, class traits>
>charT basic_regex_parser<charT, traits>::unescape_character()
>{
> charT result(0);
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
> switch(this->m_traits.escape_syntax_type(*m_position))
> {
> case regex_constants::escape_type_control_a:
> result = charT('\a');
> break;
> case regex_constants::escape_type_e:
> result = charT(27);
> break;
> case regex_constants::escape_type_control_f:
> result = charT('\f');
> break;
> case regex_constants::escape_type_control_n:
> result = charT('\n');
> break;
> case regex_constants::escape_type_control_r:
> result = charT('\r');
> break;
> case regex_constants::escape_type_control_t:
> result = charT('\t');
> break;
> case regex_constants::escape_type_control_v:
> result = charT('\v');
> break;
> case regex_constants::escape_type_word_assert:
> result = charT('\b');
> break;
> case regex_constants::escape_type_ascii_control:
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return result;
> }
># 1379 "/usr/include/boost/regex/v4/basic_regex_parser.hpp" 3 4
> result = static_cast<charT>(*m_position % 32);
> break;
> case regex_constants::escape_type_hex:
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return result;
> }
>
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)
> {
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return result;
> }
> int i = this->m_traits.toi(m_position, m_end, 16);
> if((m_position == m_end)
> || (i < 0)
> || ((std::numeric_limits<charT>::is_specialized) && (charT(i) > (std::numeric_limits<charT>::max)()))
> || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))
> {
> fail(regex_constants::error_badbrace, m_position - m_base);
> return result;
> }
> ++m_position;
> result = charT(i);
> }
> else
> {
> std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), m_end - m_position);
> int i = this->m_traits.toi(m_position, m_position + len, 16);
> if((i < 0)
> || !valid_value(charT(0), i))
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return result;
> }
> result = charT(i);
> }
> return result;
> case regex_constants::syntax_digit:
> {
>
>
> std::ptrdiff_t len = (std::min)(::boost::re_detail::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));
> const charT* bp = m_position;
> int val = this->m_traits.toi(bp, bp + 1, 8);
> if(val != 0)
> {
>
> fail(regex_constants::error_escape, m_position - m_base);
> return result;
> }
> val = this->m_traits.toi(m_position, m_position + len, 8);
> if(val < 0)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return result;
> }
> return static_cast<charT>(val);
> }
> case regex_constants::escape_type_named_char:
> {
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
>
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)
> {
> const charT* base = m_position;
>
> while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))
> ++m_position;
> if(m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
> string_type s = this->m_traits.lookup_collatename(++base, m_position++);
> if(s.empty())
> {
> fail(regex_constants::error_collate, m_position - m_base);
> return false;
> }
> if(s.size() == 1)
> {
> return s[0];
> }
> }
>
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
> default:
> result = *m_position;
> break;
> }
> ++m_position;
> return result;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_backref()
>{
> (static_cast<void> ((m_position != m_end) ? 0 : (__assert_fail ("m_position != m_end", "/usr/include/boost/regex/v4/basic_regex_parser.hpp", 1489, __PRETTY_FUNCTION__), 0)));
> const charT* pc = m_position;
> int i = this->m_traits.toi(pc, pc + 1, 10);
> if((i == 0) || (((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group) && (this->flags() & regbase::no_bk_refs)))
> {
>
> charT c = unescape_character();
> this->append_literal(c);
> }
> else if((i > 0) && (this->m_backrefs & (1u << (i-1))))
> {
> m_position = pc;
> re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));
> pb->index = i;
> }
> else
> {
> fail(regex_constants::error_backref, m_position - m_end);
> return false;
> }
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_QE()
>{
>
>
>
>
>
>
>
> ++m_position;
> const charT* start = m_position;
> const charT* end;
> do
> {
> while((m_position != m_end)
> && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape))
> ++m_position;
> if(m_position == m_end)
> {
>
> end = m_position;
> break;
> }
> if(++m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
>
> if(this->m_traits.escape_syntax_type(*m_position) == regex_constants::escape_type_E)
> {
> ++m_position;
> end = m_position - 2;
> break;
> }
>
> }while(true);
>
>
>
> while(start != end)
> {
> this->append_literal(*start);
> ++start;
> }
> return true;
>
>
>
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::parse_perl_extension()
>{
> if(++m_position == m_end)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
>
>
>
>
>
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_hash)
> {
> while((m_position != m_end)
> && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark))
> {}
> return true;
> }
>
>
>
> int markid = 0;
> std::ptrdiff_t jump_offset = 0;
> re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));
> std::ptrdiff_t last_paren_start = this->getoffset(pb);
>
> std::ptrdiff_t last_alt_point = m_alt_insert_point;
> this->m_pdata->m_data.align();
> m_alt_insert_point = this->m_pdata->m_data.size();
> std::ptrdiff_t expected_alt_point = m_alt_insert_point;
> bool restore_flags = true;
> regex_constants::syntax_option_type old_flags = this->flags();
> bool old_case_change = m_has_case_change;
> m_has_case_change = false;
>
>
>
> switch(this->m_traits.syntax_type(*m_position))
> {
> case regex_constants::syntax_colon:
>
>
>
> pb->index = markid = 0;
> ++m_position;
> break;
> case regex_constants::syntax_equal:
> pb->index = markid = -1;
> ++m_position;
> jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));
> this->m_pdata->m_data.align();
> m_alt_insert_point = this->m_pdata->m_data.size();
> break;
> case regex_constants::syntax_not:
> pb->index = markid = -2;
> ++m_position;
> jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));
> this->m_pdata->m_data.align();
> m_alt_insert_point = this->m_pdata->m_data.size();
> break;
> case regex_constants::escape_type_left_word:
> {
>
> if(++m_position == m_end)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> regex_constants::syntax_type t = this->m_traits.syntax_type(*m_position);
> if(t == regex_constants::syntax_not)
> pb->index = markid = -2;
> else if(t == regex_constants::syntax_equal)
> pb->index = markid = -1;
> else
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> ++m_position;
> jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));
> this->append_state(syntax_element_backstep, sizeof(re_brace));
> this->m_pdata->m_data.align();
> m_alt_insert_point = this->m_pdata->m_data.size();
> break;
> }
> case regex_constants::escape_type_right_word:
>
>
>
> pb->index = markid = -3;
> ++m_position;
> jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));
> this->m_pdata->m_data.align();
> m_alt_insert_point = this->m_pdata->m_data.size();
> break;
> case regex_constants::syntax_open_mark:
> {
>
> pb->index = markid = -4;
> if(++m_position == m_end)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> int v = this->m_traits.toi(m_position, m_end, 10);
> if(v > 0)
> {
> re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_assert_backref, sizeof(re_brace)));
> br->index = v;
> if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> if(++m_position == m_end)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> }
> else
> {
>
> if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_question)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> if(++m_position == m_end)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> if(this->m_traits.syntax_type(*m_position) == regex_constants::escape_type_left_word)
> {
> if(++m_position == m_end)
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)
> && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_not))
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> m_position -= 3;
> }
> else
> {
> if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)
> && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_not))
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
> m_position -= 2;
> }
> }
> break;
> }
> default:
>
>
>
> regex_constants::syntax_option_type opts = parse_options();
>
> m_has_case_change = ((opts & regbase::icase) != (this->flags() & regbase::icase));
> pb->index = markid = 0;
> if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark)
> {
>
> this->flags(opts);
> restore_flags = false;
> old_case_change |= m_has_case_change;
> }
> else if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_colon)
> {
>
> this->flags(opts);
> ++m_position;
> }
> else
> {
> fail(regex_constants::error_badrepeat, m_position - m_base);
> return false;
> }
>
>
> if(m_has_case_change)
> {
> static_cast<re_case*>(
> this->append_state(syntax_element_toggle_case, sizeof(re_case))
> )->icase = opts & regbase::icase;
> }
>
> }
>
>
>
>
> parse_all();
>
>
>
> if(0 == unwind_alts(last_paren_start))
> return false;
>
>
>
> if(m_position == m_end)
> {
> this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
> return false;
> }
> (static_cast<void> ((this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark) ? 0 : (__assert_fail ("this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark", "/usr/include/boost/regex/v4/basic_regex_parser.hpp", 1781, __PRETTY_FUNCTION__), 0)));
> ++m_position;
>
>
>
> if(restore_flags)
> {
>
> if(m_has_case_change)
> {
> static_cast<re_case*>(
> this->append_state(syntax_element_toggle_case, sizeof(re_case))
> )->icase = old_flags & regbase::icase;
> }
> this->flags(old_flags);
> }
>
>
>
> if(jump_offset)
> {
> this->m_pdata->m_data.align();
> re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset));
> jmp->alt.i = this->m_pdata->m_data.size() - this->getoffset(jmp);
> if(this->m_last_state == jmp)
> {
>
> fail(regex_constants::error_empty, m_position - m_base);
> return false;
> }
> }
>
>
>
>
> if(markid == -4)
> {
> re_syntax_base* b = this->getaddress(expected_alt_point);
> if(b->type != syntax_element_alt)
> {
> re_alt* alt = static_cast<re_alt*>(this->insert_state(expected_alt_point, syntax_element_alt, sizeof(re_alt)));
> alt->alt.i = this->m_pdata->m_data.size() - this->getoffset(alt);
> }
> else if(this->getaddress(static_cast<re_alt*>(b)->alt.i, b)->type == syntax_element_alt)
> {
> fail(regex_constants::error_bad_pattern, m_position - m_base);
> return false;
> }
> }
>
>
>
> pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));
> pb->index = markid;
> this->m_paren_start = last_paren_start;
>
>
>
> this->m_alt_insert_point = last_alt_point;
>
>
>
> m_has_case_change = old_case_change;
> return true;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::add_emacs_code(bool negate)
>{
>
>
>
> if(++m_position == m_end)
> {
> fail(regex_constants::error_escape, m_position - m_base);
> return false;
> }
> basic_char_set<charT, traits> char_set;
> if(negate)
> char_set.negate();
>
> static const charT s_punct[5] = { 'p', 'u', 'n', 'c', 't', };
>
> switch(*m_position)
> {
> case 's':
> case ' ':
> char_set.add_class(this->m_mask_space);
> break;
> case 'w':
> char_set.add_class(this->m_word_mask);
> break;
> case '_':
> char_set.add_single(digraph<charT>(charT('$')));
> char_set.add_single(digraph<charT>(charT('&')));
> char_set.add_single(digraph<charT>(charT('*')));
> char_set.add_single(digraph<charT>(charT('+')));
> char_set.add_single(digraph<charT>(charT('-')));
> char_set.add_single(digraph<charT>(charT('_')));
> char_set.add_single(digraph<charT>(charT('<')));
> char_set.add_single(digraph<charT>(charT('>')));
> break;
> case '.':
> char_set.add_class(this->m_traits.lookup_classname(s_punct, s_punct+5));
> break;
> case '(':
> char_set.add_single(digraph<charT>(charT('(')));
> char_set.add_single(digraph<charT>(charT('[')));
> char_set.add_single(digraph<charT>(charT('{')));
> break;
> case ')':
> char_set.add_single(digraph<charT>(charT(')')));
> char_set.add_single(digraph<charT>(charT(']')));
> char_set.add_single(digraph<charT>(charT('}')));
> break;
> case '"':
> char_set.add_single(digraph<charT>(charT('"')));
> char_set.add_single(digraph<charT>(charT('\'')));
> char_set.add_single(digraph<charT>(charT('`')));
> break;
> case '\'':
> char_set.add_single(digraph<charT>(charT('\'')));
> char_set.add_single(digraph<charT>(charT(',')));
> char_set.add_single(digraph<charT>(charT('#')));
> break;
> case '<':
> char_set.add_single(digraph<charT>(charT(';')));
> break;
> case '>':
> char_set.add_single(digraph<charT>(charT('\n')));
> char_set.add_single(digraph<charT>(charT('\f')));
> break;
> default:
> fail(regex_constants::error_ctype, m_position - m_base);
> return false;
> }
> if(0 == this->append_set(char_set))
> {
> fail(regex_constants::error_ctype, m_position - m_base);
> return false;
> }
> ++m_position;
> return true;
>}
>
>template <class charT, class traits>
>regex_constants::syntax_option_type basic_regex_parser<charT, traits>::parse_options()
>{
>
> regex_constants::syntax_option_type f = this->flags();
> bool breakout = false;
> do
> {
> switch(*m_position)
> {
> case 's':
> f |= regex_constants::mod_s;
> f &= ~regex_constants::no_mod_s;
> break;
> case 'm':
> f &= ~regex_constants::no_mod_m;
> break;
> case 'i':
> f |= regex_constants::icase;
> break;
> case 'x':
> f |= regex_constants::mod_x;
> break;
> default:
> breakout = true;
> continue;
> }
> if(++m_position == m_end)
> {
> fail(regex_constants::error_paren, m_position - m_base);
> return false;
> }
> }
> while(!breakout);
>
> if(*m_position == static_cast<charT>('-'))
> {
> if(++m_position == m_end)
> {
> fail(regex_constants::error_paren, m_position - m_base);
> return false;
> }
> do
> {
> switch(*m_position)
> {
> case 's':
> f &= ~regex_constants::mod_s;
> f |= regex_constants::no_mod_s;
> break;
> case 'm':
> f |= regex_constants::no_mod_m;
> break;
> case 'i':
> f &= ~regex_constants::icase;
> break;
> case 'x':
> f &= ~regex_constants::mod_x;
> break;
> default:
> breakout = true;
> continue;
> }
> if(++m_position == m_end)
> {
> fail(regex_constants::error_paren, m_position - m_base);
> return false;
> }
> }
> while(!breakout);
> }
> return f;
>}
>
>template <class charT, class traits>
>bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_start)
>{
>
>
>
>
> if((this->m_alt_insert_point == static_cast<std::ptrdiff_t>(this->m_pdata->m_data.size()))
> && m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start))
> {
> fail(regex_constants::error_empty, this->m_position - this->m_base);
> return false;
> }
>
>
>
> while(m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start))
> {
>
>
>
>
> std::ptrdiff_t jump_offset = m_alt_jumps.back();
> m_alt_jumps.pop_back();
> this->m_pdata->m_data.align();
> re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset));
> (static_cast<void> ((jmp->type == syntax_element_jump) ? 0 : (__assert_fail ("jmp->type == syntax_element_jump", "/usr/include/boost/regex/v4/basic_regex_parser.hpp", 2026, __PRETTY_FUNCTION__), 0)));
> jmp->alt.i = this->m_pdata->m_data.size() - jump_offset;
> }
> return true;
>}
>
>
>
>
>
>}
>}
># 74 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/sub_match.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/sub_match.hpp" 3 4
>namespace boost{
>
>template <class BidiIterator>
>struct sub_match : public std::pair<BidiIterator, BidiIterator>
>{
> typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type value_type;
>
>
>
> typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type difference_type;
>
> typedef BidiIterator iterator_type;
> typedef BidiIterator iterator;
> typedef BidiIterator const_iterator;
>
> bool matched;
>
> sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}
> sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}
>
>
>
>
> template <class T, class A>
> operator std::basic_string<value_type, T, A> ()const
> {
> return std::basic_string<value_type, T, A>(this->first, this->second);
> }
>
>
>
>
>
>
> difference_type length()const
> {
> difference_type n = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);
> return n;
> }
> std::basic_string<value_type> str()const
> {
> std::basic_string<value_type> result;
> std::size_t len = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);
> result.reserve(len);
> BidiIterator i = this->first;
> while(i != this->second)
> {
> result.append(1, *i);
> ++i;
> }
> return result;
> }
> int compare(const sub_match& s)const
> {
> if(matched != s.matched)
> return static_cast<int>(matched) - static_cast<int>(s.matched);
> return str().compare(s.str());
> }
> int compare(const std::basic_string<value_type>& s)const
> {
> return str().compare(s);
> }
> int compare(const value_type* p)const
> {
> return str().compare(p);
> }
>
> bool operator==(const sub_match& that)const
> { return compare(that) == 0; }
> bool operator !=(const sub_match& that)const
> { return compare(that) != 0; }
> bool operator<(const sub_match& that)const
> { return compare(that) < 0; }
> bool operator>(const sub_match& that)const
> { return compare(that) > 0; }
> bool operator<=(const sub_match& that)const
> { return compare(that) <= 0; }
> bool operator>=(const sub_match& that)const
> { return compare(that) >= 0; }
># 130 "/usr/include/boost/regex/v4/sub_match.hpp" 3 4
> sub_match(const sub_match& that, bool
>
>
>
> = true
> )
> : std::pair<BidiIterator, BidiIterator>(that),
> matched(that.matched)
> {
>
>
>
>
>
> }
> sub_match& operator=(const sub_match& that)
> {
> this->first = that.first;
> this->second = that.second;
> matched = that.matched;
>
>
>
>
> return *this;
> }
># 173 "/usr/include/boost/regex/v4/sub_match.hpp" 3 4
>};
>
>typedef sub_match<const char*> csub_match;
>typedef sub_match<std::string::const_iterator> ssub_match;
>
>typedef sub_match<const wchar_t*> wcsub_match;
>typedef sub_match<std::wstring::const_iterator> wssub_match;
>
>
>
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator == (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{ return s.compare(m.str()) == 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator != (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{ return s.compare(m.str()) != 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator < (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{ return s.compare(m.str()) < 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator <= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{ return s.compare(m.str()) <= 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator >= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{ return s.compare(m.str()) >= 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator > (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{ return s.compare(m.str()) > 0; }
>
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator == (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{ return m.str().compare(s) == 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator != (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{ return m.str().compare(s) != 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator < (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{ return m.str().compare(s) < 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator > (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{ return m.str().compare(s) > 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator <= (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{ return m.str().compare(s) <= 0; }
>template <class RandomAccessIterator, class traits, class Allocator>
>inline bool operator >= (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{ return m.str().compare(s) >= 0; }
>
>template <class RandomAccessIterator>
>inline bool operator == (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
>{ return m.str().compare(s) == 0; }
>template <class RandomAccessIterator>
>inline bool operator != (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
>{ return m.str().compare(s) != 0; }
>template <class RandomAccessIterator>
>inline bool operator > (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
>{ return m.str().compare(s) > 0; }
>template <class RandomAccessIterator>
>inline bool operator < (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
>{ return m.str().compare(s) < 0; }
>template <class RandomAccessIterator>
>inline bool operator >= (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
>{ return m.str().compare(s) >= 0; }
>template <class RandomAccessIterator>
>inline bool operator <= (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
>{ return m.str().compare(s) <= 0; }
>
>template <class RandomAccessIterator>
>inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(s) == 0; }
>template <class RandomAccessIterator>
>inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(s) != 0; }
>template <class RandomAccessIterator>
>inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(s) > 0; }
>template <class RandomAccessIterator>
>inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(s) < 0; }
>template <class RandomAccessIterator>
>inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(s) >= 0; }
>template <class RandomAccessIterator>
>inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(s) <= 0; }
>
>
>template <class RandomAccessIterator>
>inline bool operator == (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{ return m.str().compare(0, m.length(), &s, 1) == 0; }
>template <class RandomAccessIterator>
>inline bool operator != (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{ return m.str().compare(0, m.length(), &s, 1) != 0; }
>template <class RandomAccessIterator>
>inline bool operator > (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{ return m.str().compare(0, m.length(), &s, 1) > 0; }
>template <class RandomAccessIterator>
>inline bool operator < (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{ return m.str().compare(0, m.length(), &s, 1) < 0; }
>template <class RandomAccessIterator>
>inline bool operator >= (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
>template <class RandomAccessIterator>
>inline bool operator <= (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
>
>template <class RandomAccessIterator>
>inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(0, m.length(), &s, 1) == 0; }
>template <class RandomAccessIterator>
>inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(0, m.length(), &s, 1) != 0; }
>template <class RandomAccessIterator>
>inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(0, m.length(), &s, 1) > 0; }
>template <class RandomAccessIterator>
>inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(0, m.length(), &s, 1) < 0; }
>template <class RandomAccessIterator>
>inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
>template <class RandomAccessIterator>
>inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
>
>
>template <class RandomAccessIterator, class traits, class Allocator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
>operator + (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
> const sub_match<RandomAccessIterator>& m)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
> result.reserve(s.size() + m.length() + 1);
> return result.append(s).append(m.first, m.second);
>}
>template <class RandomAccessIterator, class traits, class Allocator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
>operator + (const sub_match<RandomAccessIterator>& m,
> const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
> result.reserve(s.size() + m.length() + 1);
> return result.append(m.first, m.second).append(s);
>}
>
>template <class RandomAccessIterator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
>operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
> const sub_match<RandomAccessIterator>& m)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
> result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
> return result.append(s).append(m.first, m.second);
>}
>template <class RandomAccessIterator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
>operator + (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
> result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
> return result.append(m.first, m.second).append(s);
>}
># 389 "/usr/include/boost/regex/v4/sub_match.hpp" 3 4
>template <class RandomAccessIterator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
>operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
> const sub_match<RandomAccessIterator>& m)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
> result.reserve(m.length() + 2);
> return result.append(1, s).append(m.first, m.second);
>}
>template <class RandomAccessIterator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
>operator + (const sub_match<RandomAccessIterator>& m,
> typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
> result.reserve(m.length() + 2);
> return result.append(m.first, m.second).append(1, s);
>}
>template <class RandomAccessIterator>
>inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
>operator + (const sub_match<RandomAccessIterator>& m1,
> const sub_match<RandomAccessIterator>& m2)
>{
> std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
> result.reserve(m1.length() + m2.length() + 1);
> return result.append(m1.first, m1.second).append(m2.first, m2.second);
>}
>
>template <class charT, class traits, class RandomAccessIterator>
>std::basic_ostream<charT, traits>&
> operator << (std::basic_ostream<charT, traits>& os,
> const sub_match<RandomAccessIterator>& s)
>{
> return (os << s.str());
>}
># 488 "/usr/include/boost/regex/v4/sub_match.hpp" 3 4
>}
># 77 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_format.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/regex_format.hpp" 3 4
>namespace boost{
># 34 "/usr/include/boost/regex/v4/regex_format.hpp" 3 4
> template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
>class match_results;
>
>namespace re_detail{
>
>
>
>
>
>
>template <class charT>
>struct trivial_format_traits
>{
> typedef charT char_type;
>
> static std::ptrdiff_t length(const charT* p)
> {
> return global_length(p);
> }
> static charT tolower(charT c)
> {
> return ::boost::re_detail::global_lower(c);
> }
> static charT toupper(charT c)
> {
> return ::boost::re_detail::global_upper(c);
> }
> static int value(const charT c, int radix)
> {
> int result = global_value(c);
> return result >= radix ? -1 : result;
> }
> int toi(const charT*& p1, const charT* p2, int radix)const
> {
> return global_toi(p1, p2, radix, *this);
> }
>};
>
>template <class OutputIterator, class Results, class traits>
>class basic_regex_formatter
>{
>public:
> typedef typename traits::char_type char_type;
> basic_regex_formatter(OutputIterator o, const Results& r, const traits& t)
> : m_traits(t), m_results(r), m_out(o), m_state(output_copy), m_have_conditional(false) {}
> OutputIterator format(const char_type* p1, const char_type* p2, match_flag_type f);
> OutputIterator format(const char_type* p1, match_flag_type f)
> {
> return format(p1, p1 + m_traits.length(p1), f);
> }
>private:
> typedef typename Results::value_type sub_match_type;
> enum output_state
> {
> output_copy,
> output_next_lower,
> output_next_upper,
> output_lower,
> output_upper,
> output_none
> };
>
> void put(char_type c);
> void put(const sub_match_type& sub);
> void format_all();
> void format_perl();
> void format_escape();
> void format_conditional();
> void format_until_scope_end();
>
> const traits& m_traits;
> const Results& m_results;
> OutputIterator m_out;
> const char_type* m_position;
> const char_type* m_end;
> match_flag_type m_flags;
> output_state m_state;
> bool m_have_conditional;
>private:
> basic_regex_formatter(const basic_regex_formatter&);
> basic_regex_formatter& operator=(const basic_regex_formatter&);
>};
>
>template <class OutputIterator, class Results, class traits>
>OutputIterator basic_regex_formatter<OutputIterator, Results, traits>::format(const char_type* p1, const char_type* p2, match_flag_type f)
>{
> m_position = p1;
> m_end = p2;
> m_flags = f;
> format_all();
> return m_out;
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::format_all()
>{
>
> while(m_position != m_end)
> {
> switch(*m_position)
> {
> case '&':
> if(m_flags & ::boost::regex_constants::format_sed)
> {
> ++m_position;
> put(m_results[0]);
> break;
> }
> put(*m_position++);
> break;
> case '\\':
> format_escape();
> break;
> case '(':
> if(m_flags & boost::regex_constants::format_all)
> {
> ++m_position;
> bool have_conditional = m_have_conditional;
> m_have_conditional = false;
> format_until_scope_end();
> m_have_conditional = have_conditional;
> if(m_position == m_end)
> return;
> (static_cast<void> ((*m_position == static_cast<char_type>(')')) ? 0 : (__assert_fail ("*m_position == static_cast<char_type>(')')", "/usr/include/boost/regex/v4/regex_format.hpp", 157, __PRETTY_FUNCTION__), 0)));
> ++m_position;
> break;
> }
> put(*m_position);
> ++m_position;
> break;
> case ')':
> if(m_flags & boost::regex_constants::format_all)
> {
> return;
> }
> put(*m_position);
> ++m_position;
> break;
> case ':':
> if((m_flags & boost::regex_constants::format_all) && m_have_conditional)
> {
> return;
> }
> put(*m_position);
> ++m_position;
> break;
> case '?':
> if(m_flags & boost::regex_constants::format_all)
> {
> ++m_position;
> format_conditional();
> break;
> }
> put(*m_position);
> ++m_position;
> break;
> case '$':
> if((m_flags & format_sed) == 0)
> {
> format_perl();
> break;
> }
>
> default:
> put(*m_position);
> ++m_position;
> break;
> }
> }
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::format_perl()
>{
>
>
>
>
> (static_cast<void> ((*m_position == '$') ? 0 : (__assert_fail ("*m_position == '$'", "/usr/include/boost/regex/v4/regex_format.hpp", 212, __PRETTY_FUNCTION__), 0)));
>
>
>
> if(++m_position == m_end)
> {
> --m_position;
> put(*m_position);
> ++m_position;
> return;
> }
>
>
>
> switch(*m_position)
> {
> case '&':
> ++m_position;
> put(this->m_results[0]);
> break;
> case '`':
> ++m_position;
> put(this->m_results.prefix());
> break;
> case '\'':
> ++m_position;
> put(this->m_results.suffix());
> break;
> case '$':
> put(*m_position++);
> break;
> default:
>
> {
> std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), ::boost::re_detail::distance(m_position, m_end));
> int v = m_traits.toi(m_position, m_position + len, 10);
> if(v < 0)
> {
>
> --m_position;
> put(*m_position);
> ++m_position;
> break;
> }
>
> put(this->m_results[v]);
> }
> }
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::format_escape()
>{
>
> if(++m_position == m_end)
> {
> put(static_cast<char_type>('\\'));
> return;
> }
>
> switch(*m_position)
> {
> case 'a':
> put(static_cast<char_type>('\a'));
> ++m_position;
> break;
> case 'f':
> put(static_cast<char_type>('\f'));
> ++m_position;
> break;
> case 'n':
> put(static_cast<char_type>('\n'));
> ++m_position;
> break;
> case 'r':
> put(static_cast<char_type>('\r'));
> ++m_position;
> break;
> case 't':
> put(static_cast<char_type>('\t'));
> ++m_position;
> break;
> case 'v':
> put(static_cast<char_type>('\v'));
> ++m_position;
> break;
> case 'x':
> if(++m_position == m_end)
> {
> put(static_cast<char_type>('x'));
> return;
> }
>
> if(*m_position == static_cast<char_type>('{'))
> {
> ++m_position;
> int val = m_traits.toi(m_position, m_end, 16);
> if(val < 0)
> {
>
> put(static_cast<char_type>('x'));
> put(static_cast<char_type>('{'));
> return;
> }
> if(*m_position != static_cast<char_type>('}'))
> {
> while(*m_position != static_cast<char_type>('\\'))
> --m_position;
> ++m_position;
> put(*m_position++);
> return;
> }
> ++m_position;
> put(static_cast<char_type>(val));
> return;
> }
> else
> {
> std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), ::boost::re_detail::distance(m_position, m_end));
> int val = m_traits.toi(m_position, m_position + len, 16);
> if(val < 0)
> {
> --m_position;
> put(*m_position++);
> return;
> }
> put(static_cast<char_type>(val));
> }
> break;
> case 'c':
> if(++m_position == m_end)
> {
> --m_position;
> put(*m_position++);
> return;
> }
> put(static_cast<char_type>(*m_position++ % 32));
> break;
> case 'e':
> put(static_cast<char_type>(27));
> ++m_position;
> break;
> default:
>
> if((m_flags & boost::regex_constants::format_sed) == 0)
> {
> bool breakout = false;
> switch(*m_position)
> {
> case 'l':
> ++m_position;
> m_state = output_next_lower;
> breakout = true;
> break;
> case 'L':
> ++m_position;
> m_state = output_lower;
> breakout = true;
> break;
> case 'u':
> ++m_position;
> m_state = output_next_upper;
> breakout = true;
> break;
> case 'U':
> ++m_position;
> m_state = output_upper;
> breakout = true;
> break;
> case 'E':
> ++m_position;
> m_state = output_copy;
> breakout = true;
> break;
> }
> if(breakout)
> break;
> }
>
> int v = m_traits.toi(m_position, m_position+1, 10);
> if((v > 0) || ((v == 0) && (m_flags & ::boost::regex_constants::format_sed)))
> {
> put(m_results[v]);
> break;
> }
> else if(v == 0)
> {
>
> --m_position;
> std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(4), ::boost::re_detail::distance(m_position, m_end));
> v = m_traits.toi(m_position, m_position + len, 8);
> (static_cast<void> ((v >= 0) ? 0 : (__assert_fail ("v >= 0", "/usr/include/boost/regex/v4/regex_format.hpp", 403, __PRETTY_FUNCTION__), 0)));
> put(static_cast<char_type>(v));
> break;
> }
>
> put(*m_position++);
> break;
> }
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::format_conditional()
>{
> if(m_position == m_end)
> {
>
> put(static_cast<char_type>('?'));
> return;
> }
> std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), ::boost::re_detail::distance(m_position, m_end));
> int v = m_traits.toi(m_position, m_position + len, 10);
> if(v < 0)
> {
>
> put(static_cast<char_type>('?'));
> return;
> }
>
>
> if(m_results[v].matched)
> {
> m_have_conditional = true;
> format_all();
> m_have_conditional = false;
> if((m_position != m_end) && (*m_position == static_cast<char_type>(':')))
> {
>
> ++m_position;
>
> output_state saved_state = m_state;
> m_state = output_none;
>
> format_until_scope_end();
>
> m_state = saved_state;
> }
> }
> else
> {
>
> output_state saved_state = m_state;
> m_state = output_none;
>
> m_have_conditional = true;
> format_all();
> m_have_conditional = false;
>
> m_state = saved_state;
> if((m_position != m_end) && (*m_position == static_cast<char_type>(':')))
> {
>
> ++m_position;
>
> format_until_scope_end();
> }
> }
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::format_until_scope_end()
>{
> do
> {
> format_all();
> if((m_position == m_end) || (*m_position == static_cast<char_type>(')')))
> return;
> put(*m_position++);
> }while(m_position != m_end);
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::put(char_type c)
>{
>
>
> switch(this->m_state)
> {
> case output_none:
> return;
> case output_next_lower:
> c = m_traits.tolower(c);
> this->m_state = output_copy;
> break;
> case output_next_upper:
> c = m_traits.toupper(c);
> this->m_state = output_copy;
> break;
> case output_lower:
> c = m_traits.tolower(c);
> break;
> case output_upper:
> c = m_traits.toupper(c);
> break;
> default:
> break;
> }
> *m_out = c;
> ++m_out;
>}
>
>template <class OutputIterator, class Results, class traits>
>void basic_regex_formatter<OutputIterator, Results, traits>::put(const sub_match_type& sub)
>{
> typedef typename sub_match_type::iterator iterator_type;
> iterator_type i = sub.first;
> while(i != sub.second)
> {
> put(*i);
> ++i;
> }
>}
>
>template <class S>
>class string_out_iterator
>
> : public std::iterator<std::output_iterator_tag, typename S::value_type>
>
>{
> S* out;
>public:
> string_out_iterator(S& s) : out(&s) {}
> string_out_iterator& operator++() { return *this; }
> string_out_iterator& operator++(int) { return *this; }
> string_out_iterator& operator*() { return *this; }
> string_out_iterator& operator=(typename S::value_type v)
> {
> out->append(1, v);
> return *this;
> }
># 550 "/usr/include/boost/regex/v4/regex_format.hpp" 3 4
>};
>
>template <class OutputIterator, class Iterator, class Alloc, class charT, class traits>
>OutputIterator regex_format_imp(OutputIterator out,
> const match_results<Iterator, Alloc>& m,
> const charT* p1, const charT* p2,
> match_flag_type flags,
> const traits& t
> )
>{
> if(flags & regex_constants::format_literal)
> {
> return re_detail::copy(p1, p2, out);
> }
>
> re_detail::basic_regex_formatter<
> OutputIterator,
> match_results<Iterator, Alloc>,
> traits > f(out, m, t);
> return f.format(p1, p2, flags);
>}
>
>
>}
>
>template <class OutputIterator, class Iterator, class charT>
>OutputIterator regex_format(OutputIterator out,
> const match_results<Iterator>& m,
> const charT* fmt,
> match_flag_type flags = format_all
> )
>{
> re_detail::trivial_format_traits<charT> traits;
> return re_detail::regex_format_imp(out, m, fmt, fmt + traits.length(fmt), flags, traits);
>}
>
>template <class OutputIterator, class Iterator, class charT>
>OutputIterator regex_format(OutputIterator out,
> const match_results<Iterator>& m,
> const std::basic_string<charT>& fmt,
> match_flag_type flags = format_all
> )
>{
> re_detail::trivial_format_traits<charT> traits;
> return re_detail::regex_format_imp(out, m, fmt.data(), fmt.data() + fmt.size(), flags, traits);
>}
>
>template <class Iterator, class charT>
>std::basic_string<charT> regex_format(const match_results<Iterator>& m,
> const charT* fmt,
> match_flag_type flags = format_all)
>{
> std::basic_string<charT> result;
> re_detail::string_out_iterator<std::basic_string<charT> > i(result);
> re_detail::trivial_format_traits<charT> traits;
> re_detail::regex_format_imp(i, m, fmt, fmt + traits.length(fmt), flags, traits);
> return result;
>}
>
>template <class Iterator, class charT>
>std::basic_string<charT> regex_format(const match_results<Iterator>& m,
> const std::basic_string<charT>& fmt,
> match_flag_type flags = format_all)
>{
> std::basic_string<charT> result;
> re_detail::string_out_iterator<std::basic_string<charT> > i(result);
> re_detail::trivial_format_traits<charT> traits;
> re_detail::regex_format_imp(i, m, fmt.data(), fmt.data() + fmt.size(), flags, traits);
> return result;
>}
>
>
>
>
>
>}
># 80 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/match_results.hpp" 1 3 4
># 26 "/usr/include/boost/regex/v4/match_results.hpp" 3 4
>namespace boost{
>
>
>
>
>
>template <class BidiIterator, class Allocator>
>class match_results
>{
>private:
>
> typedef std::vector<sub_match<BidiIterator>, Allocator> vector_type;
>
>
>
>public:
> typedef sub_match<BidiIterator> value_type;
>
> typedef typename Allocator::const_reference const_reference;
>
>
>
> typedef const_reference reference;
> typedef typename vector_type::const_iterator const_iterator;
> typedef const_iterator iterator;
> typedef typename re_detail::regex_iterator_traits<
> BidiIterator>::difference_type difference_type;
> typedef typename Allocator::size_type size_type;
> typedef Allocator allocator_type;
> typedef typename re_detail::regex_iterator_traits<
> BidiIterator>::value_type char_type;
> typedef std::basic_string<char_type> string_type;
>
>
> explicit match_results(const Allocator& a = Allocator())
>
> : m_subs(a), m_base() {}
>
>
>
> match_results(const match_results& m)
> : m_subs(m.m_subs), m_base(m.m_base) {}
> match_results& operator=(const match_results& m)
> {
> m_subs = m.m_subs;
> m_base = m.m_base;
> return *this;
> }
> ~match_results(){}
>
>
> size_type size() const
> { return empty() ? 0 : m_subs.size() - 2; }
> size_type max_size() const
> { return m_subs.max_size(); }
> bool empty() const
> { return m_subs.size() < 2; }
>
> difference_type length(int sub = 0) const
> {
> sub += 2;
> if((sub < (int)m_subs.size()) && (sub > 0))
> return m_subs[sub].length();
> return 0;
> }
> difference_type position(unsigned int sub = 0) const
> {
> sub += 2;
> if(sub < m_subs.size())
> {
> const sub_match<BidiIterator>& s = m_subs[sub];
> if(s.matched)
> {
> return ::boost::re_detail::distance((BidiIterator)(m_base), (BidiIterator)(s.first));
> }
> }
> return ~static_cast<difference_type>(0);
> }
> string_type str(int sub = 0) const
> {
> sub += 2;
> string_type result;
> if(sub < (int)m_subs.size() && (sub > 0))
> {
> const sub_match<BidiIterator>& s = m_subs[sub];
> if(s.matched)
> {
> result = s.str();
> }
> }
> return result;
> }
> const_reference operator[](int sub) const
> {
> sub += 2;
> if(sub < (int)m_subs.size() && (sub >= 0))
> {
> return m_subs[sub];
> }
> return m_null;
> }
>
> const_reference prefix() const
> {
> return (*this)[-1];
> }
>
> const_reference suffix() const
> {
> return (*this)[-2];
> }
> const_iterator begin() const
> {
> return (m_subs.size() > 2) ? (m_subs.begin() + 2) : m_subs.end();
> }
> const_iterator end() const
> {
> return m_subs.end();
> }
>
> template <class OutputIterator>
> OutputIterator format(OutputIterator out,
> const string_type& fmt,
> match_flag_type flags = format_default) const
> {
> re_detail::trivial_format_traits<char_type> traits;
> return re_detail::regex_format_imp(out, *this, fmt.data(), fmt.data() + fmt.size(), flags, traits);
> }
> string_type format(const string_type& fmt,
> match_flag_type flags = format_default) const
> {
> string_type result;
> re_detail::string_out_iterator<string_type> i(result);
> re_detail::trivial_format_traits<char_type> traits;
> re_detail::regex_format_imp(i, *this, fmt.data(), fmt.data() + fmt.size(), flags, traits);
> return result;
> }
>
> template <class OutputIterator, class RegexT>
> OutputIterator format(OutputIterator out,
> const string_type& fmt,
> match_flag_type flags,
> const RegexT& re) const
> {
> return ::boost::re_detail::regex_format_imp(out, *this, fmt.data(), fmt.data() + fmt.size(), flags, re.get_traits());
> }
> template <class RegexT>
> string_type format(const string_type& fmt,
> match_flag_type flags,
> const RegexT& re) const
> {
> string_type result;
> re_detail::string_out_iterator<string_type> i(result);
> ::boost::re_detail::regex_format_imp(i, *this, fmt.data(), fmt.data() + fmt.size(), flags, re.get_traits());
> return result;
> }
>
> allocator_type get_allocator() const
> {
>
> return m_subs.get_allocator();
>
>
>
> }
> void swap(match_results& that)
> {
> std::swap(m_subs, that.m_subs);
> std::swap(m_base, that.m_base);
> }
> bool operator==(const match_results& that)const
> {
> return (m_subs == that.m_subs) && (m_base == that.m_base);
> }
> bool operator!=(const match_results& that)const
> { return !(*this == that); }
># 214 "/usr/include/boost/regex/v4/match_results.hpp" 3 4
> void set_second(BidiIterator i)
> {
> (static_cast<void> ((m_subs.size() > 2) ? 0 : (__assert_fail ("m_subs.size() > 2", "/usr/include/boost/regex/v4/match_results.hpp", 216, __PRETTY_FUNCTION__), 0)));
> m_subs[2].second = i;
> m_subs[2].matched = true;
> m_subs[0].first = i;
> m_subs[0].matched = (m_subs[0].first != m_subs[0].second);
> m_null.first = i;
> m_null.second = i;
> m_null.matched = false;
> }
>
> void set_second(BidiIterator i, size_type pos, bool m = true)
> {
> pos += 2;
> (static_cast<void> ((m_subs.size() > pos) ? 0 : (__assert_fail ("m_subs.size() > pos", "/usr/include/boost/regex/v4/match_results.hpp", 229, __PRETTY_FUNCTION__), 0)));
> m_subs[pos].second = i;
> m_subs[pos].matched = m;
> if(pos == 2)
> {
> m_subs[0].first = i;
> m_subs[0].matched = (m_subs[0].first != m_subs[0].second);
> m_null.first = i;
> m_null.second = i;
> m_null.matched = false;
> }
> }
> void set_size(size_type n, BidiIterator i, BidiIterator j)
> {
> value_type v(j);
> size_type len = m_subs.size();
> if(len > n + 2)
> {
> m_subs.erase(m_subs.begin()+n+2, m_subs.end());
> std::fill(m_subs.begin(), m_subs.end(), v);
> }
> else
> {
> std::fill(m_subs.begin(), m_subs.end(), v);
> if(n+2 != len)
> m_subs.insert(m_subs.end(), n+2-len, v);
> }
> m_subs[1].first = i;
> }
> void set_base(BidiIterator pos)
> {
> m_base = pos;
> }
> BidiIterator base()const
> {
> return m_base;
> }
> void set_first(BidiIterator i)
> {
>
> m_subs[1].second = i;
> m_subs[1].matched = (m_subs[1].first != i);
>
> m_subs[2].first = i;
>
> for(size_type n = 3; n < m_subs.size(); ++n)
> {
> m_subs[n].first = m_subs[n].second = m_subs[0].second;
> m_subs[n].matched = false;
> }
> }
> void set_first(BidiIterator i, size_type pos)
> {
> (static_cast<void> ((pos+2 < m_subs.size()) ? 0 : (__assert_fail ("pos+2 < m_subs.size()", "/usr/include/boost/regex/v4/match_results.hpp", 282, __PRETTY_FUNCTION__), 0)));
> if(pos)
> m_subs[pos+2].first = i;
> else
> set_first(i);
> }
> void maybe_assign(const match_results<BidiIterator, Allocator>& m);
>
>
>private:
> vector_type m_subs;
> BidiIterator m_base;
> sub_match<BidiIterator> m_null;
>};
>
>template <class BidiIterator, class Allocator>
>void match_results<BidiIterator, Allocator>::maybe_assign(const match_results<BidiIterator, Allocator>& m)
>{
> const_iterator p1, p2;
> p1 = begin();
> p2 = m.begin();
># 313 "/usr/include/boost/regex/v4/match_results.hpp" 3 4
> BidiIterator end = this->suffix().second;
> BidiIterator base = (p1->first == end) ? this->prefix().first : (*this)[0].first;
> difference_type len1 = 0;
> difference_type len2 = 0;
> difference_type base1 = 0;
> difference_type base2 = 0;
> std::size_t i;
> for(i = 0; i < size(); ++i, ++p1, ++p2)
> {
>
>
>
>
>
>
>
> if(p1->first == end)
> {
> if(p2->first != end)
> {
>
>
> base1 = 1;
> base2 = 0;
> break;
> }
> else
> {
>
>
> if((p1->matched == false) && (p2->matched == true))
> break;
> if((p1->matched == true) && (p2->matched == false))
> return;
> continue;
> }
> }
> else if(p2->first == end)
> {
>
> return;
> }
> base1 = ::boost::re_detail::distance(base, p1->first);
> base2 = ::boost::re_detail::distance(base, p2->first);
> (static_cast<void> ((base1 >= 0) ? 0 : (__assert_fail ("base1 >= 0", "/usr/include/boost/regex/v4/match_results.hpp", 357, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((base2 >= 0) ? 0 : (__assert_fail ("base2 >= 0", "/usr/include/boost/regex/v4/match_results.hpp", 358, __PRETTY_FUNCTION__), 0)));
> if(base1 < base2) return;
> if(base2 < base1) break;
>
> len1 = ::boost::re_detail::distance((BidiIterator)p1->first, (BidiIterator)p1->second);
> len2 = ::boost::re_detail::distance((BidiIterator)p2->first, (BidiIterator)p2->second);
> (static_cast<void> ((len1 >= 0) ? 0 : (__assert_fail ("len1 >= 0", "/usr/include/boost/regex/v4/match_results.hpp", 364, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((len2 >= 0) ? 0 : (__assert_fail ("len2 >= 0", "/usr/include/boost/regex/v4/match_results.hpp", 365, __PRETTY_FUNCTION__), 0)));
> if((len1 != len2) || ((p1->matched == false) && (p2->matched == true)))
> break;
> if((p1->matched == true) && (p2->matched == false))
> return;
> }
> if(i == size())
> return;
> if(base2 < base1)
> *this = m;
> else if((len2 > len1) || ((p1->matched == false) && (p2->matched == true)) )
> *this = m;
>}
>
>template <class BidiIterator, class Allocator>
>void swap(match_results<BidiIterator, Allocator>& a, match_results<BidiIterator, Allocator>& b)
>{
> a.swap(b);
>}
>
>
>template <class charT, class traits, class BidiIterator, class Allocator>
>std::basic_ostream<charT, traits>&
> operator << (std::basic_ostream<charT, traits>& os,
> const match_results<BidiIterator, Allocator>& s)
>{
> return (os << s.str());
>}
># 405 "/usr/include/boost/regex/v4/match_results.hpp" 3 4
>}
># 83 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/protected_call.hpp" 1 3 4
># 27 "/usr/include/boost/regex/v4/protected_call.hpp" 3 4
>namespace boost{
>namespace re_detail{
>
>class abstract_protected_call
>{
>public:
> bool execute()const;
>
> virtual ~abstract_protected_call(){}
>private:
> virtual bool call()const = 0;
>};
>
>template <class T>
>class concrete_protected_call
> : public abstract_protected_call
>{
>public:
> typedef bool (T::*proc_type)();
> concrete_protected_call(T* o, proc_type p)
> : obj(o), proc(p) {}
>private:
> virtual bool call()const;
> T* obj;
> proc_type proc;
>};
>
>template <class T>
>bool concrete_protected_call<T>::call()const
>{
> return (obj->*proc)();
>}
>
>}
>}
># 86 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/perl_matcher.hpp" 1 3 4
># 15 "/usr/include/boost/regex/v4/perl_matcher.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/iterator_category.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/iterator_category.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_convertible.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>typedef char yes_type;
>struct no_type
>{
> char padding[8];
>};
>
>}
>}
># 16 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/config.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_array.hpp" 1 3 4
># 27 "/usr/include/boost/type_traits/is_array.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 10 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 3 4
># 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/int.hpp" 3 4
># 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
>namespace mpl_ {
>
>template< int N > struct int_;
>
>}
>namespace boost { namespace mpl { using ::mpl_::int_; } }
># 18 "/usr/include/boost/mpl/int.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< int N >
>struct int_
>{
> static const int value = N;
>
>
>
>
>
> typedef int_ type;
>
> typedef int value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef mpl_::int_< static_cast<int>((value + 1)) > next;
> typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
>
>
>
>
>
>
> operator int() const { return static_cast<int>(this->value); }
>};
>
>
>template< int N >
>int const mpl_::int_< N >::value;
>
>
>}
># 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
># 11 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename F > struct template_arity;
>
>}}}
># 12 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 45 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/comma_if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
># 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 16 "/usr/include/boost/preprocessor/comma_if.hpp" 2 3 4
># 46 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/repeat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
># 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 16 "/usr/include/boost/preprocessor/repeat.hpp" 2 3 4
># 47 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/inc.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/inc.hpp" 2 3 4
># 48 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
># 11 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
># 1 "/usr/include/boost/mpl/integral_c.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/integral_c.hpp" 3 4
># 1 "/usr/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/integral_c_fwd.hpp" 3 4
>namespace mpl_ {
>
>
>
>
>
>template< typename T, T N > struct integral_c;
>
>
>}
>namespace boost { namespace mpl { using ::mpl_::integral_c; } }
># 18 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
># 32 "/usr/include/boost/mpl/integral_c.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< typename T, T N >
>struct integral_c
>{
> static const T value = N;
>
>
>
>
>
> typedef integral_c type;
>
> typedef T value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef integral_c< T, static_cast<T>((value + 1)) > next;
> typedef integral_c< T, static_cast<T>((value - 1)) > prior;
>
>
>
>
>
>
> operator T() const { return static_cast<T>(this->value); }
>};
>
>
>template< typename T, T N >
>T const integral_c< T, N >::value;
>
>
>}
># 33 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
>
>
>
>
>namespace mpl_ {
>
>template< bool C >
>struct integral_c<bool, C>
>{
> static const bool value = C;
> typedef integral_c_tag tag;
> typedef integral_c type;
> typedef bool value_type;
> operator bool() const { return this->value; }
>};
>}
># 12 "/usr/include/boost/type_traits/integral_constant.hpp" 2 3 4
>
>namespace boost{
>
>
>
>
>template <class T, T val>
>
>struct integral_constant : public mpl::integral_c<T, val>
>{
>
>
> typedef integral_constant<T,val> type;
># 58 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
>};
>
>template<> struct integral_constant<bool,true> : public mpl::true_
>{
>
>
>
>
> typedef integral_constant<bool,true> type;
>};
>template<> struct integral_constant<bool,false> : public mpl::false_
>{
>
>
>
>
> typedef integral_constant<bool,false> type;
>};
>
>typedef integral_constant<bool,true> true_type;
>typedef integral_constant<bool,false> false_type;
>
>}
># 16 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
># 18 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 28 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
>
>namespace boost {
>
>
>
>template< typename T > struct is_array : ::boost::integral_constant<bool,false> { };
>
>template< typename T, std::size_t N > struct is_array< T[N] > : ::boost::integral_constant<bool,true> { };
>template< typename T, std::size_t N > struct is_array< T const[N] > : ::boost::integral_constant<bool,true> { };
>template< typename T, std::size_t N > struct is_array< T volatile[N] > : ::boost::integral_constant<bool,true> { };
>template< typename T, std::size_t N > struct is_array< T const volatile[N] > : ::boost::integral_constant<bool,true> { };
>
>template< typename T > struct is_array< T[] > : ::boost::integral_constant<bool,true> { };
>template< typename T > struct is_array< T const[] > : ::boost::integral_constant<bool,true> { };
>template< typename T > struct is_array< T volatile[] > : ::boost::integral_constant<bool,true> { };
>template< typename T > struct is_array< T const volatile[] > : ::boost::integral_constant<bool,true> { };
># 86 "/usr/include/boost/type_traits/is_array.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 89 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/add_reference.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_reference.hpp" 1 3 4
># 32 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
>
>namespace boost {
>
>
>
>template< typename T > struct is_reference : ::boost::integral_constant<bool,false> { };
>template< typename T > struct is_reference< T& > : ::boost::integral_constant<bool,true> { };
># 111 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 114 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 18 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 55 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
>template <typename T>
>struct add_reference_impl
>{
> typedef T& type;
>};
>
>
>template< typename T > struct add_reference_impl<T&> { typedef T& type; };
>
>
>
>
>
>template<> struct add_reference_impl<void> { typedef void type; };
>
>template<> struct add_reference_impl<void const> { typedef void const type; };
>template<> struct add_reference_impl<void volatile> { typedef void volatile type; };
>template<> struct add_reference_impl<void const volatile> { typedef void const volatile type; };
>
>
>}
>
>template< typename T > struct add_reference { typedef typename detail::add_reference_impl<T>::type type; };
>
>
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 88 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
># 19 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/ice.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/ice.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_or.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/detail/ice_or.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
>struct ice_or;
>
>template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
>struct ice_or
>{
> static const bool value = true;
>};
>
>template <>
>struct ice_or<false, false, false, false, false, false, false>
>{
> static const bool value = false;
>};
>
>}
>}
># 16 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_and.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/ice_and.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
>struct ice_and;
>
>template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
>struct ice_and
>{
> static const bool value = false;
>};
>
>template <>
>struct ice_and<true, true, true, true, true, true, true>
>{
> static const bool value = true;
>};
>
>}
>}
># 17 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_not.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/detail/ice_not.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <bool b>
>struct ice_not
>{
> static const bool value = true;
>};
>
>template <>
>struct ice_not<true>
>{
> static const bool value = false;
>};
>
>}
>}
># 18 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <int b1, int b2>
>struct ice_eq
>{
> static const bool value = (b1 == b2);
>};
>
>template <int b1, int b2>
>struct ice_ne
>{
> static const bool value = (b1 != b2);
>};
>
>
>template <int b1, int b2> bool const ice_eq<b1,b2>::value;
>template <int b1, int b2> bool const ice_ne<b1,b2>::value;
>
>
>}
>}
># 19 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/is_arithmetic.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_integral.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 16 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>template< typename T > struct is_integral : ::boost::integral_constant<bool,false> { };
>
>template<> struct is_integral< unsigned char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< unsigned short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< unsigned int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< unsigned long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const volatile > : ::boost::integral_constant<bool,true> { };
>
>template<> struct is_integral< signed char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< signed short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< signed int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< signed long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const volatile > : ::boost::integral_constant<bool,true> { };
>
>template<> struct is_integral< bool > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const volatile > : ::boost::integral_constant<bool,true> { };
>
>
>
>
>
>template<> struct is_integral< wchar_t > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const volatile > : ::boost::integral_constant<bool,true> { };
># 60 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
>template<> struct is_integral< ::boost::ulong_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_integral< ::boost::long_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const volatile > : ::boost::integral_constant<bool,true> { };
>
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 70 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_float.hpp" 1 3 4
># 13 "/usr/include/boost/type_traits/is_float.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4
>
>namespace boost {
>
>
>template< typename T > struct is_float : ::boost::integral_constant<bool,false> { };
>template<> struct is_float< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_float< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const volatile > : ::boost::integral_constant<bool,true> { };
>template<> struct is_float< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const volatile > : ::boost::integral_constant<bool,true> { };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4
># 14 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 19 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
>
>template< typename T >
>struct is_arithmetic_impl
>{
> static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value);
>
>
>
>
>};
>
>}
>
>
>template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 42 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
># 21 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_abstract.hpp" 1 3 4
># 52 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
># 53 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/is_class.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_union.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/is_union.hpp" 3 4
># 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
># 1 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 1 3 4
># 95 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 3 4
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
># 15 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 1 3 4
># 23 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
>namespace boost {
>namespace detail {
>
>
>
>
>
>
>
>template <typename T> struct cv_traits_imp {};
>
>template <typename T>
>struct cv_traits_imp<T*>
>{
> static const bool is_const = false;
> static const bool is_volatile = false;
> typedef T unqualified_type;
>};
>
>template <typename T>
>struct cv_traits_imp<const T*>
>{
> static const bool is_const = true;
> static const bool is_volatile = false;
> typedef T unqualified_type;
>};
>
>template <typename T>
>struct cv_traits_imp<volatile T*>
>{
> static const bool is_const = false;
> static const bool is_volatile = true;
> typedef T unqualified_type;
>};
>
>template <typename T>
>struct cv_traits_imp<const volatile T*>
>{
> static const bool is_const = true;
> static const bool is_volatile = true;
> typedef T unqualified_type;
>};
># 92 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
>}
>}
># 16 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
># 22 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>template< typename T > struct remove_cv { typedef typename detail::cv_traits_imp<T*>::unqualified_type type; };
>template< typename T > struct remove_cv<T&> { typedef T& type; };
>
>template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
>template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
>template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };
># 52 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
># 55 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 20 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 36 "/usr/include/boost/type_traits/is_union.hpp" 3 4
>template <typename T> struct is_union_impl
>{
> static const bool value = false;
>};
>
>}
>
>template< typename T > struct is_union : ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 48 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
># 15 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
># 33 "/usr/include/boost/type_traits/is_class.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 34 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 53 "/usr/include/boost/type_traits/is_class.hpp" 3 4
>template <class U> ::boost::type_traits::yes_type is_class_tester(void(U::*)(void));
>template <class U> ::boost::type_traits::no_type is_class_tester(...);
>
>template <typename T>
>struct is_class_impl
>{
>
> static const bool value = (::boost::type_traits::ice_and< sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type), ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value >::value);
>
>
>
>
>
>};
># 115 "/usr/include/boost/type_traits/is_class.hpp" 3 4
>}
>
>
>
>
>
>template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { };
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 127 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
># 54 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 60 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
>
>
>namespace boost {
>namespace detail{
>
>
>template<class T>
>struct is_abstract_imp2
>{
>
>
>
>
> template<class U>
> static type_traits::no_type check_sig(U (*)[1]);
> template<class U>
> static type_traits::yes_type check_sig(...);
>
>
>
>
> typedef char boost_static_assert_typedef_81 [ ::boost::STATIC_ASSERTION_FAILURE< (bool)( sizeof(T) != 0 ) >::value ];
>
>
>
>
> static const unsigned s1 = sizeof(is_abstract_imp2<T>::template check_sig<T>(0));
>
>
>
>
> static const bool value = (s1 == sizeof(type_traits::yes_type));
>
>};
>
>template <bool v>
>struct is_abstract_select
>{
> template <class T>
> struct rebind
> {
> typedef is_abstract_imp2<T> type;
> };
>};
>template <>
>struct is_abstract_select<false>
>{
> template <class T>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <class T>
>struct is_abstract_imp
>{
> typedef is_abstract_select< ::boost::is_class<T>::value> selector;
> typedef typename selector::template rebind<T> binder;
> typedef typename binder::type type;
>
> static const bool value = type::value;
>};
>
>
>}
>
>
>template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { };
>
>
>
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 136 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
># 23 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 31 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
>
>namespace boost {
># 44 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>namespace detail {
># 111 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>struct any_conversion
>{
> template <typename T> any_conversion(const volatile T&);
> template <typename T> any_conversion(T&);
>};
>
>template <typename T> struct checker
>{
> static boost::type_traits::no_type _m_check(any_conversion ...);
> static boost::type_traits::yes_type _m_check(T, int);
>};
>
>template <typename From, typename To>
>struct is_convertible_basic_impl
>{
> static From _m_from;
> static bool const value = sizeof( detail::checker<To>::_m_check(_m_from, 0) )
> == sizeof(::boost::type_traits::yes_type);
>};
># 224 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>template <typename From, typename To>
>struct is_convertible_impl
>{
> typedef typename add_reference<From>::type ref_type;
> static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value);
>
>
>
>
>
>
>
>};
>
>
>template <bool trivial1, bool trivial2, bool abstract_target>
>struct is_convertible_impl_select
>{
> template <class From, class To>
> struct rebind
> {
> typedef is_convertible_impl<From, To> type;
> };
>};
>
>template <>
>struct is_convertible_impl_select<true, true, false>
>{
> template <class From, class To>
> struct rebind
> {
> typedef true_type type;
> };
>};
>
>template <>
>struct is_convertible_impl_select<false, false, true>
>{
> template <class From, class To>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <>
>struct is_convertible_impl_select<true, false, true>
>{
> template <class From, class To>
> struct rebind
> {
> typedef false_type type;
> };
>};
>
>template <typename From, typename To>
>struct is_convertible_impl_dispatch_base
>{
>
> typedef is_convertible_impl_select<
> ::boost::is_arithmetic<From>::value,
> ::boost::is_arithmetic<To>::value,
>
> ::boost::is_abstract<To>::value
>
>
>
> > selector;
>
>
>
> typedef typename selector::template rebind<From, To> isc_binder;
> typedef typename isc_binder::type type;
>};
>
>template <typename From, typename To>
>struct is_convertible_impl_dispatch
> : public is_convertible_impl_dispatch_base<From, To>::type
>{};
># 324 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
> template<> struct is_convertible_impl< void,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { static const bool value = (true); };
># 334 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
>template< typename To > struct is_convertible_impl< void,To > { static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void > { static const bool value = (false); };
>
>template< typename To > struct is_convertible_impl< void const,To > { static const bool value = (false); };
>template< typename To > struct is_convertible_impl< void volatile,To > { static const bool value = (false); };
>template< typename To > struct is_convertible_impl< void const volatile,To > { static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void const > { static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void volatile > { static const bool value = (false); };
>template< typename From > struct is_convertible_impl< From,void const volatile > { static const bool value = (false); };
>
>
>
>}
>
>template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { };
>
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 353 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
># 26 "/usr/include/boost/regex/v4/iterator_category.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_pointer.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
># 28 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
># 24 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1 3 4
># 25 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
>namespace boost {
>namespace type_traits {
>
>template <typename T>
>struct is_mem_fun_pointer_impl
>{
> static const bool value = false;
>};
>
>
>
>
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };
>
>
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };
>
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };
>
>template <class R, class T >
>struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };
>
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };
>
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };
>
>template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
>struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
># 776 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
>}
>}
># 25 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
># 35 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 36 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
>
>namespace boost {
>
>
>
>template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<T>::value> { };
># 122 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 125 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
># 29 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
># 39 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 40 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
>
>namespace boost {
>
>
>
>
>
>
>template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { };
>template< typename T, typename U > struct is_member_pointer : ::boost::integral_constant<bool,true> { };
># 104 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 107 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
># 25 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
># 38 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
># 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
># 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
># 39 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
>
>namespace boost {
>
>
>
>namespace detail {
>
>template< typename T > struct is_pointer_helper
>{
> static const bool value = false;
>};
># 58 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
>template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };
>template< typename T > struct is_pointer_helper<T* const> { static const bool value = true; };
>template< typename T > struct is_pointer_helper<T* volatile> { static const bool value = true; };
>template< typename T > struct is_pointer_helper<T* const volatile> { static const bool value = true; };
>
>
>
>template< typename T >
>struct is_pointer_impl
>{
> static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<T>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value);
>
>
>
>
>
>
>
>};
>
>}
>
>template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { };
># 145 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
>}
>
># 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
># 148 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
># 27 "/usr/include/boost/regex/v4/iterator_category.hpp" 2 3 4
>
>namespace boost{
>namespace detail{
>
>template <class I>
>struct is_random_imp
>{
>private:
> typedef typename std::iterator_traits::iterator_category cat;
>public:
> static const bool value = (::boost::is_convertible<cat*, std::random_access_iterator_tag*>::value);
>};
>
>template <class I>
>struct is_random_pointer_imp
>{
> static const bool value = true;
>};
>
>template <bool is_pointer_type>
>struct is_random_imp_selector
>{
> template <class I>
> struct rebind
> {
> typedef is_random_imp type;
> };
>};
>
>template <>
>struct is_random_imp_selector<true>
>{
> template <class I>
> struct rebind
> {
> typedef is_random_pointer_imp type;
> };
>};
>
>}
>
>template <class I>
>struct is_random_access_iterator
>{
>private:
> typedef detail::is_random_imp_selector< ::boost::is_pointer::value> selector;
> typedef typename selector::template rebind bound_type;
> typedef typename bound_type::type answer;
>public:
> static const bool value = answer::value;
>};
>
>
>template <class I>
>const bool is_random_access_iterator::value;
>
>
>}
># 16 "/usr/include/boost/regex/v4/perl_matcher.hpp" 2 3 4
>
>
>
>
>
>namespace boost{
>namespace re_detail{
>
>
>
>
> void verify_options(boost::regex_constants::syntax_option_type ef, match_flag_type mf);
>
>
>
>template <class charT>
>bool can_start(charT c, const unsigned char* map, unsigned char mask)
>{
> return ((c < static_cast<charT>(0)) ? true : ((c >= static_cast<charT>(1 << 8)) ? true : map[c] & mask));
>}
>inline bool can_start(char c, const unsigned char* map, unsigned char mask)
>{
> return map[(unsigned char)c] & mask;
>}
>inline bool can_start(signed char c, const unsigned char* map, unsigned char mask)
>{
> return map[(unsigned char)c] & mask;
>}
>inline bool can_start(unsigned char c, const unsigned char* map, unsigned char mask)
>{
> return map[c] & mask;
>}
>inline bool can_start(unsigned short c, const unsigned char* map, unsigned char mask)
>{
> return ((c >= (1 << 8)) ? true : map[c] & mask);
>}
># 71 "/usr/include/boost/regex/v4/perl_matcher.hpp" 3 4
>template <class C, class T, class A>
>inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
>{
> if(0 == *p)
> {
> if(s.empty() || ((s.size() == 1) && (s[0] == 0)))
> return 0;
> }
> return s.compare(p);
>}
># 100 "/usr/include/boost/regex/v4/perl_matcher.hpp" 3 4
>template <class Seq, class C>
>inline int string_compare(const Seq& s, const C* p)
>{
> std::size_t i = 0;
> while((i < s.size()) && (p[i] == s[i]))
> {
> ++i;
> }
> return (i == s.size()) ? -p[i] : s[i] - p[i];
>}
>
>
>
>template<class charT>
>inline const charT* re_skip_past_null(const charT* p)
>{
> while (*p != static_cast<charT>(0)) ++p;
> return ++p;
>}
>
>template <class iterator, class charT, class traits_type, class char_classT>
>iterator re_is_set_member(iterator next,
> iterator last,
> const re_set_long<char_classT>* set_,
> const regex_data<charT, traits_type>& e, bool icase)
>{
> const charT* p = reinterpret_cast<const charT*>(set_+1);
> iterator ptr;
> unsigned int i;
>
>
> if(next == last) return next;
>
> typedef typename traits_type::string_type traits_string_type;
> const ::boost::regex_traits_wrapper<traits_type>& traits_inst = *(e.m_ptraits);
>
>
>
> (void)traits_inst;
>
>
>
> for(i = 0; i < set_->csingles; ++i)
> {
> ptr = next;
> if(*p == static_cast<charT>(0))
> {
>
> if(traits_inst.translate(*ptr, icase) != *p)
> {
> while(*p == static_cast<charT>(0))++p;
> continue;
> }
> return set_->isnot ? next : (ptr == next) ? ++next : ptr;
> }
> else
> {
> while(*p && (ptr != last))
> {
> if(traits_inst.translate(*ptr, icase) != *p)
> break;
> ++p;
> ++ptr;
> }
>
> if(*p == static_cast<charT>(0))
> return set_->isnot ? next : (ptr == next) ? ++next : ptr;
>
> p = re_skip_past_null(p);
> }
> }
>
> charT col = traits_inst.translate(*next, icase);
>
>
> if(set_->cranges || set_->cequivalents)
> {
> traits_string_type s1;
>
>
> if(set_->cranges)
> {
> if((e.m_flags & regex_constants::collate) == 0)
> s1.assign(1, col);
> else
> {
> charT a[2] = { col, charT(0), };
> s1 = traits_inst.transform(a, a + 1);
> }
> for(i = 0; i < set_->cranges; ++i)
> {
> if(string_compare(s1,p) >= 0)
> {
> do{ ++p; }while(*p);
> ++p;
> if(string_compare(s1,p) <= 0)
> return set_->isnot ? next : ++next;
> }
> else
> {
>
> do{ ++p; }while(*p);
> ++p;
> }
>
> do{ ++p; }while(*p);
> ++p;
> }
> }
>
>
> if(set_->cequivalents)
> {
> charT a[2] = { col, charT(0), };
> s1 = traits_inst.transform_primary(a, a +1);
> for(i = 0; i < set_->cequivalents; ++i)
> {
> if(string_compare(s1,p) == 0)
> return set_->isnot ? next : ++next;
>
> do{ ++p; }while(*p);
> ++p;
> }
> }
> }
> if(traits_inst.isctype(col, set_->cclasses) == true)
> return set_->isnot ? next : ++next;
> return set_->isnot ? ++next : next;
>}
>
>template <class BidiIterator>
>class repeater_count
>{
> repeater_count** stack;
> repeater_count* next;
> int id;
> std::size_t count;
> BidiIterator start_pos;
>public:
> repeater_count(repeater_count** s)
> {
> stack = s;
> next = 0;
> id = -1;
> count = 0;
> }
> repeater_count(int i, repeater_count** s, BidiIterator start)
> : start_pos(start)
> {
> id = i;
> stack = s;
> next = *stack;
> *stack = this;
> if(id > next->id)
> count = 0;
> else
> {
> repeater_count* p = next;
> while(p->id != id)
> p = p->next;
> count = p->count;
> start_pos = p->start_pos;
> }
> }
> ~repeater_count()
> {
> *stack = next;
> }
> std::size_t get_count() { return count; }
> int get_id() { return id; }
> std::size_t operator++() { return ++count; }
> bool check_null_repeat(const BidiIterator& pos, std::size_t max)
> {
>
>
>
> bool result = (count == 0) ? false : (pos == start_pos);
> if(result)
> count = max;
> else
> start_pos = pos;
> return result;
> }
>};
>
>struct saved_state;
>
>enum saved_state_type
>{
> saved_type_end = 0,
> saved_type_paren = 1,
> saved_type_recurse = 2,
> saved_type_assertion = 3,
> saved_state_alt = 4,
> saved_state_repeater_count = 5,
> saved_state_extra_block = 6,
> saved_state_greedy_single_repeat = 7,
> saved_state_rep_slow_dot = 8,
> saved_state_rep_fast_dot = 9,
> saved_state_rep_char = 10,
> saved_state_rep_short_set = 11,
> saved_state_rep_long_set = 12,
> saved_state_non_greedy_long_repeat = 13,
> saved_state_count = 14
>};
>
>
>
>
>
>
>template <class BidiIterator, class Allocator, class traits>
>class perl_matcher
>{
>public:
> typedef typename traits::char_type char_type;
> typedef perl_matcher<BidiIterator, Allocator, traits> self_type;
> typedef bool (self_type::*matcher_proc_type)(void);
> typedef typename traits::size_type traits_size_type;
> typedef typename is_byte<char_type>::width_type width_type;
> typedef typename regex_iterator_traits<BidiIterator>::difference_type difference_type;
>
> perl_matcher(BidiIterator first, BidiIterator end,
> match_results<BidiIterator, Allocator>& what,
> const basic_regex<char_type, traits>& e,
> match_flag_type f);
>
> bool match();
> bool match_imp();
> bool find();
> bool find_imp();
>
>
>
>
>
> void setf(match_flag_type f)
> { m_match_flags |= f; }
> void unsetf(match_flag_type f)
> { m_match_flags &= ~f; }
>
>private:
> void estimate_max_state_count(std::random_access_iterator_tag*);
> void estimate_max_state_count(void*);
> bool match_prefix();
> bool match_all_states();
>
>
> bool match_startmark();
> bool match_endmark();
> bool match_literal();
> bool match_start_line();
> bool match_end_line();
> bool match_wild();
> bool match_match();
> bool match_word_boundary();
> bool match_within_word();
> bool match_word_start();
> bool match_word_end();
> bool match_buffer_start();
> bool match_buffer_end();
> bool match_backref();
> bool match_long_set();
> bool match_set();
> bool match_jump();
> bool match_alt();
> bool match_rep();
> bool match_combining();
> bool match_soft_buffer_end();
> bool match_restart_continue();
> bool match_long_set_repeat();
> bool match_set_repeat();
> bool match_char_repeat();
> bool match_dot_repeat_fast();
> bool match_dot_repeat_slow();
> bool match_backstep();
> bool match_assert_backref();
> bool match_toggle_case();
>
>
>
>
>
> bool find_restart_any();
> bool find_restart_word();
> bool find_restart_line();
> bool find_restart_buf();
> bool find_restart_lit();
>
>private:
>
> match_results<BidiIterator, Allocator>& m_result;
>
> scoped_ptr<match_results<BidiIterator, Allocator> > m_temp_match;
>
> match_results<BidiIterator, Allocator>* m_presult;
>
> BidiIterator base;
>
> BidiIterator last;
>
> BidiIterator position;
>
> BidiIterator restart;
>
> BidiIterator search_base;
>
> const basic_regex<char_type, traits>& re;
>
> const ::boost::regex_traits_wrapper<traits>& traits_inst;
>
> const re_syntax_base* pstate;
>
> match_flag_type m_match_flags;
>
> difference_type state_count;
>
> difference_type max_state_count;
>
> bool icase;
>
> bool m_has_partial_match;
>
> bool m_has_found_match;
>
> bool m_independent;
>
> repeater_count<BidiIterator>* next_count;
>
> repeater_count<BidiIterator> rep_obj;
>
> typename traits::char_class_type m_word_mask;
>
> unsigned char match_any_mask;
>
>
>
>
>
> typedef bool (self_type::*unwind_proc_type)(bool);
>
> void extend_stack();
> bool unwind(bool);
> bool unwind_end(bool);
> bool unwind_paren(bool);
> bool unwind_recursion_stopper(bool);
> bool unwind_assertion(bool);
> bool unwind_alt(bool);
> bool unwind_repeater_counter(bool);
> bool unwind_extra_block(bool);
> bool unwind_greedy_single_repeat(bool);
> bool unwind_slow_dot_repeat(bool);
> bool unwind_fast_dot_repeat(bool);
> bool unwind_char_repeat(bool);
> bool unwind_short_set_repeat(bool);
> bool unwind_long_set_repeat(bool);
> bool unwind_non_greedy_repeat(bool);
> void destroy_single_repeat();
> void push_matched_paren(int index, const sub_match<BidiIterator>& sub);
> void push_recursion_stopper();
> void push_assertion(const re_syntax_base* ps, bool positive);
> void push_alt(const re_syntax_base* ps);
> void push_repeater_count(int i, repeater_count<BidiIterator>** s);
> void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id);
> void push_non_greedy_repeat(const re_syntax_base* ps);
>
>
>
> saved_state* m_stack_base;
>
> saved_state* m_backup_state;
>
>
> bool m_recursive_result;
>
> unsigned used_block_count;
>
>
>
>
> perl_matcher& operator=(const perl_matcher&)
> {
> return *this;
> }
> perl_matcher(const perl_matcher& that)
> : m_result(that.m_result), re(that.re), traits_inst(that.traits_inst), rep_obj(0) {}
>};
>
>
>
>
>
>}
>
>
>
>
>
>}
>
>
>
>
>
>
>
># 1 "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp" 1 3 4
># 29 "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp" 3 4
>namespace boost{
>namespace re_detail{
>
>template <class T>
>inline void inplace_destroy(T* p)
>{
> (void)p;
> p->~T();
>}
>
>struct saved_state
>{
> union{
> unsigned int id;
>
> std::size_t padding1;
> std::ptrdiff_t padding2;
> void* padding3;
> };
> saved_state(unsigned i) : id(i) {}
>};
>
>template <class BidiIterator>
>struct saved_matched_paren : public saved_state
>{
> int index;
> sub_match<BidiIterator> sub;
> saved_matched_paren(int i, const sub_match<BidiIterator>& s) : saved_state(1), index(i), sub(s){};
>};
>
>template <class BidiIterator>
>struct saved_position : public saved_state
>{
> const re_syntax_base* pstate;
> BidiIterator position;
> saved_position(const re_syntax_base* ps, BidiIterator pos, int i) : saved_state(i), pstate(ps), position(pos){};
>};
>
>template <class BidiIterator>
>struct saved_assertion : public saved_position<BidiIterator>
>{
> bool positive;
> saved_assertion(bool p, const re_syntax_base* ps, BidiIterator pos)
> : saved_position<BidiIterator>(ps, pos, saved_type_assertion), positive(p){};
>};
>
>template <class BidiIterator>
>struct saved_repeater : public saved_state
>{
> repeater_count<BidiIterator> count;
> saved_repeater(int i, repeater_count<BidiIterator>** s, BidiIterator start)
> : saved_state(saved_state_repeater_count), count(i,s,start){}
>};
>
>struct saved_extra_block : public saved_state
>{
> saved_state *base, *end;
> saved_extra_block(saved_state* b, saved_state* e)
> : saved_state(saved_state_extra_block), base(b), end(e) {}
>};
>
>struct save_state_init
>{
> saved_state** stack;
> save_state_init(saved_state** base, saved_state** end)
> : stack(base)
> {
> *base = static_cast<saved_state*>(get_mem_block());
> *end = reinterpret_cast<saved_state*>(reinterpret_cast<char*>(*base)+4096);
> --(*end);
> (void) new (*end)saved_state(0);
> (static_cast<void> ((*end > *base) ? 0 : (__assert_fail ("*end > *base", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 100, __PRETTY_FUNCTION__), 0)));
> }
> ~save_state_init()
> {
> put_mem_block(*stack);
> *stack = 0;
> }
>};
>
>template <class BidiIterator>
>struct saved_single_repeat : public saved_state
>{
> std::size_t count;
> const re_repeat* rep;
> BidiIterator last_position;
> saved_single_repeat(std::size_t c, const re_repeat* r, BidiIterator lp, int arg_id)
> : saved_state(arg_id), count(c), rep(r), last_position(lp){}
>};
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
>{
> static matcher_proc_type const s_match_vtable[29] =
> {
> (&perl_matcher<BidiIterator, Allocator, traits>::match_startmark),
> &perl_matcher<BidiIterator, Allocator, traits>::match_endmark,
> &perl_matcher<BidiIterator, Allocator, traits>::match_literal,
> &perl_matcher<BidiIterator, Allocator, traits>::match_start_line,
> &perl_matcher<BidiIterator, Allocator, traits>::match_end_line,
> &perl_matcher<BidiIterator, Allocator, traits>::match_wild,
> &perl_matcher<BidiIterator, Allocator, traits>::match_match,
> &perl_matcher<BidiIterator, Allocator, traits>::match_word_boundary,
> &perl_matcher<BidiIterator, Allocator, traits>::match_within_word,
> &perl_matcher<BidiIterator, Allocator, traits>::match_word_start,
> &perl_matcher<BidiIterator, Allocator, traits>::match_word_end,
> &perl_matcher<BidiIterator, Allocator, traits>::match_buffer_start,
> &perl_matcher<BidiIterator, Allocator, traits>::match_buffer_end,
> &perl_matcher<BidiIterator, Allocator, traits>::match_backref,
> &perl_matcher<BidiIterator, Allocator, traits>::match_long_set,
> &perl_matcher<BidiIterator, Allocator, traits>::match_set,
> &perl_matcher<BidiIterator, Allocator, traits>::match_jump,
> &perl_matcher<BidiIterator, Allocator, traits>::match_alt,
> &perl_matcher<BidiIterator, Allocator, traits>::match_rep,
> &perl_matcher<BidiIterator, Allocator, traits>::match_combining,
> &perl_matcher<BidiIterator, Allocator, traits>::match_soft_buffer_end,
> &perl_matcher<BidiIterator, Allocator, traits>::match_restart_continue,
> (::boost::is_random_access_iterator<BidiIterator>::value ? &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast : &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow),
> &perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::match_backstep,
> &perl_matcher<BidiIterator, Allocator, traits>::match_assert_backref,
> &perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case,
> };
>
> push_recursion_stopper();
> do{
> while(pstate)
> {
> matcher_proc_type proc = s_match_vtable[pstate->type];
> ++state_count;
> if(!(this->*proc)())
> {
> if(state_count > max_state_count)
> raise_error(traits_inst, regex_constants::error_space);
> if((m_match_flags & match_partial) && (position == last) && (position != search_base))
> m_has_partial_match = true;
> if(false == unwind(false))
> return m_recursive_result;
> }
> }
> }while(unwind(true));
> return m_recursive_result;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>void perl_matcher<BidiIterator, Allocator, traits>::extend_stack()
>{
> if(used_block_count)
> {
> --used_block_count;
> saved_state* stack_base;
> saved_state* backup_state;
> stack_base = static_cast<saved_state*>(get_mem_block());
> backup_state = reinterpret_cast<saved_state*>(reinterpret_cast<char*>(stack_base)+4096);
> saved_extra_block* block = static_cast<saved_extra_block*>(backup_state);
> --block;
> (void) new (block) saved_extra_block(m_stack_base, m_backup_state);
> m_stack_base = stack_base;
> m_backup_state = block;
> }
> else
> raise_error(traits_inst, regex_constants::error_size);
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_matched_paren(int index, const sub_match<BidiIterator>& sub)
>{
> (static_cast<void> ((index) ? 0 : (__assert_fail ("index", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 198, __PRETTY_FUNCTION__), 0)));
> saved_matched_paren<BidiIterator>* pmp = static_cast<saved_matched_paren<BidiIterator>*>(m_backup_state);
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = static_cast<saved_matched_paren<BidiIterator>*>(m_backup_state);
> --pmp;
> }
> (void) new (pmp)saved_matched_paren<BidiIterator>(index, sub);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_recursion_stopper()
>{
> saved_state* pmp = m_backup_state;
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = m_backup_state;
> --pmp;
> }
> (void) new (pmp)saved_state(saved_type_recurse);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_assertion(const re_syntax_base* ps, bool positive)
>{
> saved_assertion<BidiIterator>* pmp = static_cast<saved_assertion<BidiIterator>*>(m_backup_state);
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = static_cast<saved_assertion<BidiIterator>*>(m_backup_state);
> --pmp;
> }
> (void) new (pmp)saved_assertion<BidiIterator>(positive, ps, position);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_alt(const re_syntax_base* ps)
>{
> saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
> --pmp;
> }
> (void) new (pmp)saved_position<BidiIterator>(ps, position, saved_state_alt);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_non_greedy_repeat(const re_syntax_base* ps)
>{
> saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
> --pmp;
> }
> (void) new (pmp)saved_position<BidiIterator>(ps, position, saved_state_non_greedy_long_repeat);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_repeater_count(int i, repeater_count<BidiIterator>** s)
>{
> saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
> --pmp;
> }
> (void) new (pmp)saved_repeater<BidiIterator>(i, s, position);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id)
>{
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
> --pmp;
> if(pmp < m_stack_base)
> {
> extend_stack();
> pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
> --pmp;
> }
> (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, id);
> m_backup_state = pmp;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
>{
> int index = static_cast<const re_brace*>(pstate)->index;
> switch(index)
> {
> case 0:
> pstate = pstate->next.p;
> break;
> case -1:
> case -2:
> {
>
> const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
> pstate = pstate->next.p->next.p;
> push_assertion(next_pstate, index == -1);
> break;
> }
> case -3:
> {
>
> bool old_independent = m_independent;
> m_independent = true;
> const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
> pstate = pstate->next.p->next.p;
> bool r = match_all_states();
> pstate = next_pstate;
> m_independent = old_independent;
># 356 "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp" 3 4
> return r;
> }
> case -4:
> {
>
> const re_alt* alt = static_cast<const re_alt*>(pstate->next.p);
> (static_cast<void> ((alt->type == syntax_element_alt) ? 0 : (__assert_fail ("alt->type == syntax_element_alt", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 362, __PRETTY_FUNCTION__), 0)));
> pstate = alt->next.p;
> if(pstate->type == syntax_element_assert_backref)
> {
> if(!match_assert_backref())
> pstate = alt->alt.p;
> break;
> }
> else
> {
>
> (static_cast<void> ((pstate->type == syntax_element_startmark) ? 0 : (__assert_fail ("pstate->type == syntax_element_startmark", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 373, __PRETTY_FUNCTION__), 0)));
> bool negated = static_cast<const re_brace*>(pstate)->index == -2;
> BidiIterator saved_position = position;
> const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
> pstate = pstate->next.p->next.p;
> bool r = match_all_states();
> position = saved_position;
> if(negated)
> r = !r;
> if(r)
> pstate = next_pstate;
> else
> pstate = alt->alt.p;
> break;
> }
> }
> default:
> {
> (static_cast<void> ((index > 0) ? 0 : (__assert_fail ("index > 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 391, __PRETTY_FUNCTION__), 0)));
> if((m_match_flags & match_nosubs) == 0)
> {
> push_matched_paren(index, (*m_presult)[index]);
> m_presult->set_first(position, index);
> }
> pstate = pstate->next.p;
> break;
> }
> }
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_alt()
>{
> bool take_first, take_second;
> const re_alt* jmp = static_cast<const re_alt*>(pstate);
>
>
> if(position == last)
> {
> take_first = jmp->can_be_null & mask_take;
> take_second = jmp->can_be_null & mask_skip;
> }
> else
> {
> take_first = can_start(*position, jmp->_map, (unsigned char)mask_take);
> take_second = can_start(*position, jmp->_map, (unsigned char)mask_skip);
> }
>
> if(take_first)
> {
>
>
> if(take_second)
> {
> push_alt(jmp->alt.p);
> }
> pstate = pstate->next.p;
> return true;
> }
> if(take_second)
> {
> pstate = jmp->alt.p;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
>{
>
>
>
>
>
>
>
> const re_repeat* rep = static_cast<const re_repeat*>(pstate);
>
>
> bool take_first, take_second;
> if(position == last)
> {
> take_first = rep->can_be_null & mask_take;
> take_second = rep->can_be_null & mask_skip;
> }
> else
> {
> take_first = can_start(*position, rep->_map, (unsigned char)mask_take);
> take_second = can_start(*position, rep->_map, (unsigned char)mask_skip);
> }
>
> if(take_first || (next_count->get_id() != rep->id))
> {
>
>
> push_repeater_count(rep->id, &next_count);
> }
>
>
>
>
>
> next_count->check_null_repeat(position, rep->max);
>
> if(next_count->get_count() < rep->min)
> {
>
> if(take_first)
> {
>
> ++(*next_count);
> pstate = rep->next.p;
> return true;
> }
> return false;
> }
>
> bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
> if(greedy)
> {
>
> if((next_count->get_count() < rep->max) && take_first)
> {
> if(take_second)
> {
>
> push_alt(rep->alt.p);
> }
>
> ++(*next_count);
> pstate = rep->next.p;
> return true;
> }
> else if(take_second)
> {
> pstate = rep->alt.p;
> return true;
> }
> return false;
> }
> else
> {
>
> if(take_second)
> {
>
> push_non_greedy_repeat(rep->next.p);
> pstate = rep->alt.p;
> return true;
> }
> if((next_count->get_count() < rep->max) && take_first)
> {
>
> ++(*next_count);
> pstate = rep->next.p;
> return true;
> }
> }
> return false;
>
>
>
>
>
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow()
>{
> unsigned count = 0;
> const re_repeat* rep = static_cast<const re_repeat*>(pstate);
> re_syntax_base* psingle = rep->next.p;
>
> while(count < rep->min)
> {
> pstate = psingle;
> if(!match_wild())
> return false;
> ++count;
> }
> bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
> if(greedy)
> {
>
> while(count < rep->max)
> {
> pstate = psingle;
> if(!match_wild())
> break;
> ++count;
> }
>
> if((rep->leading) && (count < rep->max))
> restart = position;
>
> if(count - rep->min)
> push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
>
> pstate = rep->alt.p;
> return true;
> }
> else
> {
>
> if(count < rep->max)
> push_single_repeat(count, rep, position, saved_state_rep_slow_dot);
> pstate = rep->alt.p;
> return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
> }
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
>{
> if(m_match_flags & match_not_dot_null)
> return match_dot_repeat_slow();
> if((static_cast<const re_dot*>(pstate->next.p)->mask & match_any_mask) == 0)
> return match_dot_repeat_slow();
>
> const re_repeat* rep = static_cast<const re_repeat*>(pstate);
> bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
> unsigned count = static_cast<unsigned>((std::min)(static_cast<unsigned>(::boost::re_detail::distance(position, last)), static_cast<unsigned>(greedy ? rep->max : rep->min)));
> if(rep->min > count)
> {
> position = last;
> return false;
> }
> std::advance(position, count);
>
> if(greedy)
> {
> if((rep->leading) && (count < rep->max))
> restart = position;
>
> if(count - rep->min)
> push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
>
> pstate = rep->alt.p;
> return true;
> }
> else
> {
>
> if(count < rep->max)
> push_single_repeat(count, rep, position, saved_state_rep_fast_dot);
> pstate = rep->alt.p;
> return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
> }
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
>{
>
>
>
>
>
>
>
> const re_repeat* rep = static_cast<const re_repeat*>(pstate);
> (static_cast<void> ((1 == static_cast<const re_literal*>(rep->next.p)->length) ? 0 : (__assert_fail ("1 == static_cast<const re_literal*>(rep->next.p)->length", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 637, __PRETTY_FUNCTION__), 0)));
> const char_type what = *reinterpret_cast<const char_type*>(static_cast<const re_literal*>(rep->next.p) + 1);
> std::size_t count = 0;
>
>
>
> bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
> std::size_t desired = greedy ? rep->max : rep->min;
> if(::boost::is_random_access_iterator<BidiIterator>::value)
> {
> BidiIterator end = position;
> std::advance(end, (std::min)((std::size_t)::boost::re_detail::distance(position, last), desired));
> BidiIterator origin(position);
> while((position != end) && (traits_inst.translate(*position, icase) == what))
> {
> ++position;
> }
> count = (unsigned)::boost::re_detail::distance(origin, position);
> }
> else
> {
> while((count < desired) && (position != last) && (traits_inst.translate(*position, icase) == what))
> {
> ++position;
> ++count;
> }
> }
>
> if(count < rep->min)
> return false;
>
> if(greedy)
> {
> if((rep->leading) && (count < rep->max))
> restart = position;
>
> if(count - rep->min)
> push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
>
> pstate = rep->alt.p;
> return true;
> }
> else
> {
>
> if(count < rep->max)
> push_single_repeat(count, rep, position, saved_state_rep_char);
> pstate = rep->alt.p;
> return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
> }
>
>
>
>
>
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
>{
>
>
>
>
>
>
>
> const re_repeat* rep = static_cast<const re_repeat*>(pstate);
> const unsigned char* map = static_cast<const re_set*>(rep->next.p)->_map;
> std::size_t count = 0;
>
>
>
> bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
> std::size_t desired = greedy ? rep->max : rep->min;
> if(::boost::is_random_access_iterator<BidiIterator>::value)
> {
> BidiIterator end = position;
> std::advance(end, (std::min)((std::size_t)::boost::re_detail::distance(position, last), desired));
> BidiIterator origin(position);
> while((position != end) && map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
> {
> ++position;
> }
> count = (unsigned)::boost::re_detail::distance(origin, position);
> }
> else
> {
> while((count < desired) && (position != last) && map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
> {
> ++position;
> ++count;
> }
> }
>
> if(count < rep->min)
> return false;
>
> if(greedy)
> {
> if((rep->leading) && (count < rep->max))
> restart = position;
>
> if(count - rep->min)
> push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
>
> pstate = rep->alt.p;
> return true;
> }
> else
> {
>
> if(count < rep->max)
> push_single_repeat(count, rep, position, saved_state_rep_short_set);
> pstate = rep->alt.p;
> return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
> }
>
>
>
>
>
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
>{
>
>
>
>
>
>
>
> typedef typename traits::char_class_type mask_type;
> const re_repeat* rep = static_cast<const re_repeat*>(pstate);
> const re_set_long<mask_type>* set = static_cast<const re_set_long<mask_type>*>(pstate->next.p);
> std::size_t count = 0;
>
>
>
> bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
> std::size_t desired = greedy ? rep->max : rep->min;
> if(::boost::is_random_access_iterator<BidiIterator>::value)
> {
> BidiIterator end = position;
> std::advance(end, (std::min)((std::size_t)::boost::re_detail::distance(position, last), desired));
> BidiIterator origin(position);
> while((position != end) && (position != re_is_set_member(position, last, set, re.get_data(), icase)))
> {
> ++position;
> }
> count = (unsigned)::boost::re_detail::distance(origin, position);
> }
> else
> {
> while((count < desired) && (position != last) && (position != re_is_set_member(position, last, set, re.get_data(), icase)))
> {
> ++position;
> ++count;
> }
> }
>
> if(count < rep->min)
> return false;
>
> if(greedy)
> {
> if((rep->leading) && (count < rep->max))
> restart = position;
>
> if(count - rep->min)
> push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
>
> pstate = rep->alt.p;
> return true;
> }
> else
> {
>
> if(count < rep->max)
> push_single_repeat(count, rep, position, saved_state_rep_long_set);
> pstate = rep->alt.p;
> return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
> }
>
>
>
>
>
>
>}
># 839 "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp" 3 4
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind(bool have_match)
>{
> static unwind_proc_type const s_unwind_table[14] =
> {
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_end,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_paren,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_stopper,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_assertion,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_alt,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_greedy_single_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_slow_dot_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_fast_dot_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_char_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_short_set_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat,
> &perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat,
> };
>
> m_recursive_result = have_match;
> unwind_proc_type unwinder;
> bool cont;
>
>
>
> do
> {
> unwinder = s_unwind_table[m_backup_state->id];
> cont = (this->*unwinder)(m_recursive_result);
> }while(cont);
>
>
>
> return pstate ? true : false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_end(bool)
>{
> pstate = 0;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_paren(bool have_match)
>{
> saved_matched_paren<BidiIterator>* pmp = static_cast<saved_matched_paren<BidiIterator>*>(m_backup_state);
>
> if(have_match == false)
> {
> m_presult->set_first(pmp->sub.first, pmp->index);
> m_presult->set_second(pmp->sub.second, pmp->index, pmp->sub.matched);
> }
># 902 "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp" 3 4
> m_backup_state = pmp+1;
> boost::re_detail::inplace_destroy(pmp);
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_stopper(bool)
>{
> boost::re_detail::inplace_destroy(m_backup_state++);
> pstate = 0;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_assertion(bool r)
>{
> saved_assertion<BidiIterator>* pmp = static_cast<saved_assertion<BidiIterator>*>(m_backup_state);
> pstate = pmp->pstate;
> position = pmp->position;
> bool result = (r == pmp->positive);
> m_recursive_result = pmp->positive ? r : !r;
> boost::re_detail::inplace_destroy(pmp++);
> m_backup_state = pmp;
> return !result;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_alt(bool r)
>{
> saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
> if(!r)
> {
> pstate = pmp->pstate;
> position = pmp->position;
> }
> boost::re_detail::inplace_destroy(pmp++);
> m_backup_state = pmp;
> return r;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter(bool)
>{
> saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
> boost::re_detail::inplace_destroy(pmp++);
> m_backup_state = pmp;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block(bool)
>{
> saved_extra_block* pmp = static_cast<saved_extra_block*>(m_backup_state);
> void* condemmed = m_stack_base;
> m_stack_base = pmp->base;
> m_backup_state = pmp->end;
> boost::re_detail::inplace_destroy(pmp);
> put_mem_block(condemmed);
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline void perl_matcher<BidiIterator, Allocator, traits>::destroy_single_repeat()
>{
> saved_single_repeat<BidiIterator>* p = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
> boost::re_detail::inplace_destroy(p++);
> m_backup_state = p;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_greedy_single_repeat(bool r)
>{
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
>
>
> if(r)
> {
> destroy_single_repeat();
> return true;
> }
>
> const re_repeat* rep = pmp->rep;
> std::size_t count = pmp->count;
> (static_cast<void> ((rep->next.p != 0) ? 0 : (__assert_fail ("rep->next.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 985, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->alt.p != 0) ? 0 : (__assert_fail ("rep->alt.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 986, __PRETTY_FUNCTION__), 0)));
>
> count -= rep->min;
>
> if((m_match_flags & match_partial) && (position == last))
> m_has_partial_match = true;
>
> (static_cast<void> ((count) ? 0 : (__assert_fail ("count", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 993, __PRETTY_FUNCTION__), 0)));
> position = pmp->last_position;
>
>
> do
> {
> --position;
> --count;
> ++state_count;
> }while(count && !can_start(*position, rep->_map, mask_skip));
>
>
> if(count == 0)
> {
> destroy_single_repeat();
> if(!can_start(*position, rep->_map, mask_skip))
> return true;
> }
> else
> {
> pmp->count = count + rep->min;
> pmp->last_position = position;
> }
> pstate = rep->alt.p;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_slow_dot_repeat(bool r)
>{
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
>
>
> if(r)
> {
> destroy_single_repeat();
> return true;
> }
>
> const re_repeat* rep = pmp->rep;
> std::size_t count = pmp->count;
> (static_cast<void> ((rep->type == syntax_element_dot_rep) ? 0 : (__assert_fail ("rep->type == syntax_element_dot_rep", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1034, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p != 0) ? 0 : (__assert_fail ("rep->next.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1035, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->alt.p != 0) ? 0 : (__assert_fail ("rep->alt.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1036, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p->type == syntax_element_wild) ? 0 : (__assert_fail ("rep->next.p->type == syntax_element_wild", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1037, __PRETTY_FUNCTION__), 0)));
>
> (static_cast<void> ((count < rep->max) ? 0 : (__assert_fail ("count < rep->max", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1039, __PRETTY_FUNCTION__), 0)));
> pstate = rep->next.p;
> position = pmp->last_position;
>
> if(position != last)
> {
>
> do
> {
> if(!match_wild())
> {
>
> destroy_single_repeat();
> return true;
> }
> ++count;
> ++state_count;
> pstate = rep->next.p;
> }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
> }
> if(position == last)
> {
>
> destroy_single_repeat();
> if(0 == (rep->can_be_null & mask_skip))
> return true;
> }
> else if(count == rep->max)
> {
>
> destroy_single_repeat();
> if(!can_start(*position, rep->_map, mask_skip))
> return true;
> }
> else
> {
> pmp->count = count;
> pmp->last_position = position;
> }
> pstate = rep->alt.p;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_fast_dot_repeat(bool r)
>{
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
>
>
> if(r)
> {
> destroy_single_repeat();
> return true;
> }
>
> const re_repeat* rep = pmp->rep;
> std::size_t count = pmp->count;
>
> (static_cast<void> ((count < rep->max) ? 0 : (__assert_fail ("count < rep->max", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1097, __PRETTY_FUNCTION__), 0)));
> position = pmp->last_position;
> if(position != last)
> {
>
>
> do
> {
> ++position;
> ++count;
> ++state_count;
> }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
> }
>
> if(position == last)
> {
>
> destroy_single_repeat();
> if(0 == (rep->can_be_null & mask_skip))
> return true;
> }
> else if(count == rep->max)
> {
>
> destroy_single_repeat();
> if(!can_start(*position, rep->_map, mask_skip))
> return true;
> }
> else
> {
> pmp->count = count;
> pmp->last_position = position;
> }
> pstate = rep->alt.p;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_char_repeat(bool r)
>{
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
>
>
> if(r)
> {
> destroy_single_repeat();
> return true;
> }
>
> const re_repeat* rep = pmp->rep;
> std::size_t count = pmp->count;
> pstate = rep->next.p;
> const char_type what = *reinterpret_cast<const char_type*>(static_cast<const re_literal*>(pstate) + 1);
> position = pmp->last_position;
>
> (static_cast<void> ((rep->type == syntax_element_char_rep) ? 0 : (__assert_fail ("rep->type == syntax_element_char_rep", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1152, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p != 0) ? 0 : (__assert_fail ("rep->next.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1153, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->alt.p != 0) ? 0 : (__assert_fail ("rep->alt.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1154, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p->type == syntax_element_literal) ? 0 : (__assert_fail ("rep->next.p->type == syntax_element_literal", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1155, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((count < rep->max) ? 0 : (__assert_fail ("count < rep->max", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1156, __PRETTY_FUNCTION__), 0)));
>
> if(position != last)
> {
>
> do
> {
> if(traits_inst.translate(*position, icase) != what)
> {
>
> destroy_single_repeat();
> return true;
> }
> ++count;
> ++ position;
> ++state_count;
> pstate = rep->next.p;
> }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
> }
> if(position == last)
> {
>
> destroy_single_repeat();
> if(0 == (rep->can_be_null & mask_skip))
> return true;
> }
> else if(count == rep->max)
> {
>
> destroy_single_repeat();
> if(!can_start(*position, rep->_map, mask_skip))
> return true;
> }
> else
> {
> pmp->count = count;
> pmp->last_position = position;
> }
> pstate = rep->alt.p;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_short_set_repeat(bool r)
>{
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
>
>
> if(r)
> {
> destroy_single_repeat();
> return true;
> }
>
> const re_repeat* rep = pmp->rep;
> std::size_t count = pmp->count;
> pstate = rep->next.p;
> const unsigned char* map = static_cast<const re_set*>(rep->next.p)->_map;
> position = pmp->last_position;
>
> (static_cast<void> ((rep->type == syntax_element_short_set_rep) ? 0 : (__assert_fail ("rep->type == syntax_element_short_set_rep", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1216, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p != 0) ? 0 : (__assert_fail ("rep->next.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1217, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->alt.p != 0) ? 0 : (__assert_fail ("rep->alt.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1218, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p->type == syntax_element_set) ? 0 : (__assert_fail ("rep->next.p->type == syntax_element_set", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1219, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((count < rep->max) ? 0 : (__assert_fail ("count < rep->max", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1220, __PRETTY_FUNCTION__), 0)));
>
> if(position != last)
> {
>
> do
> {
> if(!map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
> {
>
> destroy_single_repeat();
> return true;
> }
> ++count;
> ++ position;
> ++state_count;
> pstate = rep->next.p;
> }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
> }
> if(position == last)
> {
>
> destroy_single_repeat();
> if(0 == (rep->can_be_null & mask_skip))
> return true;
> }
> else if(count == rep->max)
> {
>
> destroy_single_repeat();
> if(!can_start(*position, rep->_map, mask_skip))
> return true;
> }
> else
> {
> pmp->count = count;
> pmp->last_position = position;
> }
> pstate = rep->alt.p;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat(bool r)
>{
> typedef typename traits::char_class_type mask_type;
> saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
>
>
> if(r)
> {
> destroy_single_repeat();
> return true;
> }
>
> const re_repeat* rep = pmp->rep;
> std::size_t count = pmp->count;
> pstate = rep->next.p;
> const re_set_long<mask_type>* set = static_cast<const re_set_long<mask_type>*>(pstate);
> position = pmp->last_position;
>
> (static_cast<void> ((rep->type == syntax_element_long_set_rep) ? 0 : (__assert_fail ("rep->type == syntax_element_long_set_rep", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1281, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p != 0) ? 0 : (__assert_fail ("rep->next.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1282, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->alt.p != 0) ? 0 : (__assert_fail ("rep->alt.p != 0", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1283, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((rep->next.p->type == syntax_element_long_set) ? 0 : (__assert_fail ("rep->next.p->type == syntax_element_long_set", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1284, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((count < rep->max) ? 0 : (__assert_fail ("count < rep->max", "/usr/include/boost/regex/v4/perl_matcher_non_recursive.hpp", 1285, __PRETTY_FUNCTION__), 0)));
>
> if(position != last)
> {
>
> do
> {
> if(position == re_is_set_member(position, last, set, re.get_data(), icase))
> {
>
> destroy_single_repeat();
> return true;
> }
> ++position;
> ++count;
> ++state_count;
> pstate = rep->next.p;
> }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
> }
> if(position == last)
> {
>
> destroy_single_repeat();
> if(0 == (rep->can_be_null & mask_skip))
> return true;
> }
> else if(count == rep->max)
> {
>
> destroy_single_repeat();
> if(!can_start(*position, rep->_map, mask_skip))
> return true;
> }
> else
> {
> pmp->count = count;
> pmp->last_position = position;
> }
> pstate = rep->alt.p;
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat(bool r)
>{
> saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
> if(!r)
> {
> position = pmp->position;
> pstate = pmp->pstate;
> ++(*next_count);
> }
> boost::re_detail::inplace_destroy(pmp++);
> m_backup_state = pmp;
> return r;
>}
>
>}
>}
># 507 "/usr/include/boost/regex/v4/perl_matcher.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/perl_matcher_common.hpp" 1 3 4
># 31 "/usr/include/boost/regex/v4/perl_matcher_common.hpp" 3 4
>namespace boost{
>namespace re_detail{
>
>template <class BidiIterator, class Allocator, class traits>
>perl_matcher<BidiIterator, Allocator, traits>::perl_matcher(BidiIterator first, BidiIterator end,
> match_results<BidiIterator, Allocator>& what,
> const basic_regex<char_type, traits>& e,
> match_flag_type f)
> : m_result(what), base(first), last(end),
> position(first), re(e), traits_inst(e.get_traits()),
> m_independent(false), next_count(&rep_obj), rep_obj(&next_count)
>{
> typedef typename regex_iterator_traits<BidiIterator>::iterator_category category;
>
> if(e.empty())
> {
>
> std::invalid_argument ex("Invalid regular expression object");
> boost::throw_exception(ex);
> }
> pstate = 0;
> m_match_flags = f;
> icase = re.flags() & regex_constants::icase;
> estimate_max_state_count(static_cast<category*>(0));
> if(!(m_match_flags & (match_perl|match_posix)))
> {
> if((re.flags() & (regbase::main_option_type|regbase::no_perl_ex)) == 0)
> m_match_flags |= match_perl;
> else if((re.flags() & (regbase::main_option_type|regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex))
> m_match_flags |= match_perl;
> else
> m_match_flags |= match_posix;
> }
> if(m_match_flags & match_posix)
> {
> m_temp_match.reset(new match_results<BidiIterator, Allocator>());
> m_presult = m_temp_match.get();
> }
> else
> m_presult = &m_result;
>
> m_stack_base = 0;
> m_backup_state = 0;
>
>
> const char_type w = static_cast<char_type>('w');
> m_word_mask = traits_inst.lookup_classname(&w, &w+1);
>
> match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? re_detail::test_not_newline : re_detail::test_newline);
>}
>
>template <class BidiIterator, class Allocator, class traits>
>void perl_matcher<BidiIterator, Allocator, traits>::estimate_max_state_count(std::random_access_iterator_tag*)
>{
> static const difference_type k = 100000;
> difference_type dist = boost::re_detail::distance(base, last);
> traits_size_type states = static_cast<traits_size_type>(re.size());
> states *= states;
> difference_type lim = ((std::numeric_limits<difference_type>::max)() - k) / states;
> if(dist >= lim)
> max_state_count = (std::numeric_limits<difference_type>::max)();
> else
> max_state_count = k + states * dist;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>void perl_matcher<BidiIterator, Allocator, traits>::estimate_max_state_count(void*)
>{
>
> max_state_count = 100000000;
>}
># 128 "/usr/include/boost/regex/v4/perl_matcher_common.hpp" 3 4
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match()
>{
>
>
>
> return match_imp();
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_imp()
>{
>
>
> save_state_init init(&m_stack_base, &m_backup_state);
> used_block_count = 1024;
>
> try{
>
>
>
>
> position = base;
> search_base = base;
> state_count = 0;
> m_match_flags |= regex_constants::match_all;
> m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), base, last);
> m_presult->set_base(base);
> if(m_match_flags & match_posix)
> m_result = *m_presult;
> verify_options(re.flags(), m_match_flags);
> if(0 == match_prefix())
> return false;
> return m_result[0].second == last;
>
>
> }
> catch(...)
> {
>
>
>
> while(unwind(true)){}
> throw;
> }
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find()
>{
>
>
>
> return find_imp();
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find_imp()
>{
> static matcher_proc_type const s_find_vtable[7] =
> {
> &perl_matcher<BidiIterator, Allocator, traits>::find_restart_any,
> &perl_matcher<BidiIterator, Allocator, traits>::find_restart_word,
> &perl_matcher<BidiIterator, Allocator, traits>::find_restart_line,
> &perl_matcher<BidiIterator, Allocator, traits>::find_restart_buf,
> &perl_matcher<BidiIterator, Allocator, traits>::match_prefix,
> &perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit,
> &perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit,
> };
>
>
>
> save_state_init init(&m_stack_base, &m_backup_state);
> used_block_count = 1024;
>
> try{
>
>
>
> state_count = 0;
> if((m_match_flags & regex_constants::match_init) == 0)
> {
>
> position = base;
> search_base = base;
> pstate = re.get_first_state();
> m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), base, last);
> m_presult->set_base(base);
> m_match_flags |= regex_constants::match_init;
> }
> else
> {
>
> search_base = position = m_result[0].second;
>
>
> if(((m_match_flags & match_not_null) == 0) && (m_result.length() == 0))
> {
> if(position == last)
> return false;
> else
> ++position;
> }
>
> m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), search_base, last);
> if(base != search_base)
> m_match_flags |= match_prev_avail;
> }
> if(m_match_flags & match_posix)
> {
> m_result.set_size(re.mark_count(), base, last);
> m_result.set_base(base);
> }
>
> verify_options(re.flags(), m_match_flags);
>
> unsigned type = (m_match_flags & match_continuous) ?
> static_cast<unsigned int>(regbase::restart_continue)
> : static_cast<unsigned int>(re.get_restart_type());
>
>
> matcher_proc_type proc = s_find_vtable[type];
> return (this->*proc)();
>
>
> }
> catch(...)
> {
>
>
>
> while(unwind(true)){}
> throw;
> }
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_prefix()
>{
> m_has_partial_match = false;
> m_has_found_match = false;
> pstate = re.get_first_state();
> m_presult->set_first(position);
> restart = position;
> match_all_states();
> if(!m_has_found_match && m_has_partial_match && (m_match_flags & match_partial))
> {
> m_has_found_match = true;
> m_presult->set_second(last, 0, false);
> position = last;
> }
># 296 "/usr/include/boost/regex/v4/perl_matcher_common.hpp" 3 4
> if(!m_has_found_match)
> position = restart;
> return m_has_found_match;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_endmark()
>{
> int index = static_cast<const re_brace*>(pstate)->index;
> if(index > 0)
> {
> if((m_match_flags & match_nosubs) == 0)
> m_presult->set_second(position, index);
> }
> else if((index < 0) && (index != -4))
> {
>
> pstate = 0;
> return true;
> }
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_literal()
>{
> unsigned int len = static_cast<const re_literal*>(pstate)->length;
> const char_type* what = reinterpret_cast<const char_type*>(static_cast<const re_literal*>(pstate) + 1);
>
>
>
> for(unsigned int i = 0; i < len; ++i, ++position)
> {
> if((position == last) || (traits_inst.translate(*position, icase) != what[i]))
> return false;
> }
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_start_line()
>{
> if(position == base)
> {
> if((m_match_flags & match_prev_avail) == 0)
> {
> if((m_match_flags & match_not_bol) == 0)
> {
> pstate = pstate->next.p;
> return true;
> }
> return false;
> }
> }
> else if(m_match_flags & match_single_line)
> return false;
>
>
> BidiIterator t(position);
> --t;
> if(position != last)
> {
> if(is_separator(*t) && !((*t == static_cast<char_type>('\r')) && (*position == static_cast<char_type>('\n'))) )
> {
> pstate = pstate->next.p;
> return true;
> }
> }
> else if(is_separator(*t))
> {
> pstate = pstate->next.p;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_end_line()
>{
> if(position != last)
> {
> if(m_match_flags & match_single_line)
> return false;
>
> if(is_separator(*position))
> {
> if((position != base) || (m_match_flags & match_prev_avail))
> {
>
> BidiIterator t(position);
> --t;
> if((*t == static_cast<char_type>('\r')) && (*position == static_cast<char_type>('\n')))
> {
> return false;
> }
> }
> pstate = pstate->next.p;
> return true;
> }
> }
> else if((m_match_flags & match_not_eol) == 0)
> {
> pstate = pstate->next.p;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_wild()
>{
> if(position == last)
> return false;
> if(is_separator(*position) && ((match_any_mask & static_cast<const re_dot*>(pstate)->mask) == 0))
> return false;
> if((*position == char_type(0)) && (m_match_flags & match_not_dot_null))
> return false;
> pstate = pstate->next.p;
> ++position;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_match()
>{
> if((m_match_flags & match_not_null) && (position == (*m_presult)[0].first))
> return false;
> if((m_match_flags & match_all) && (position != last))
> return false;
> if((m_match_flags & regex_constants::match_not_initial_null) && (position == search_base))
> return false;
> m_presult->set_second(position);
> pstate = 0;
> m_has_found_match = true;
> if((m_match_flags & match_posix) == match_posix)
> {
> m_result.maybe_assign(*m_presult);
> if((m_match_flags & match_any) == 0)
> return false;
> }
># 446 "/usr/include/boost/regex/v4/perl_matcher_common.hpp" 3 4
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_word_boundary()
>{
> bool b;
> if(position != last)
> {
>
>
>
>
> b = traits_inst.isctype(*position, m_word_mask);
>
> }
> else
> {
> b = (m_match_flags & match_not_eow) ? true : false;
> }
> if((position == base) && ((m_match_flags & match_prev_avail) == 0))
> {
> if(m_match_flags & match_not_bow)
> b ^= true;
> else
> b ^= false;
> }
> else
> {
> --position;
> b ^= traits_inst.isctype(*position, m_word_mask);
> ++position;
> }
> if(b)
> {
> pstate = pstate->next.p;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_within_word()
>{
> if(position == last)
> return false;
>
> if(traits_inst.isctype(*position, m_word_mask))
> {
> bool b;
> if((position == base) && ((m_match_flags & match_prev_avail) == 0))
> return false;
> else
> {
> --position;
> b = traits_inst.isctype(*position, m_word_mask);
> ++position;
> }
> if(b)
> {
> pstate = pstate->next.p;
> return true;
> }
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_word_start()
>{
> if(position == last)
> return false;
> if(!traits_inst.isctype(*position, m_word_mask))
> return false;
> if((position == base) && ((m_match_flags & match_prev_avail) == 0))
> {
> if(m_match_flags & match_not_bow)
> return false;
> }
> else
> {
>
> BidiIterator t(position);
> --t;
> if(traits_inst.isctype(*t, m_word_mask))
> return false;
> }
>
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_word_end()
>{
> if((position == base) && ((m_match_flags & match_prev_avail) == 0))
> return false;
> BidiIterator t(position);
> --t;
> if(traits_inst.isctype(*t, m_word_mask) == false)
> return false;
>
> if(position == last)
> {
> if(m_match_flags & match_not_eow)
> return false;
> }
> else
> {
>
> if(traits_inst.isctype(*position, m_word_mask))
> return false;
> }
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_buffer_start()
>{
> if((position != base) || (m_match_flags & match_not_bob))
> return false;
>
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_buffer_end()
>{
> if((position != last) || (m_match_flags & match_not_eob))
> return false;
>
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_backref()
>{
>
> BidiIterator i = (*m_presult)[static_cast<const re_brace*>(pstate)->index].first;
> BidiIterator j = (*m_presult)[static_cast<const re_brace*>(pstate)->index].second;
> while(i != j)
> {
> if((position == last) || (traits_inst.translate(*position, icase) != traits_inst.translate(*i, icase)))
> return false;
> ++i;
> ++position;
> }
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set()
>{
> typedef typename traits::char_class_type char_class_type;
>
> if(position == last)
> return false;
> BidiIterator t = re_is_set_member(position, last, static_cast<const re_set_long<char_class_type>*>(pstate), re.get_data(), icase);
> if(t != position)
> {
> pstate = pstate->next.p;
> position = t;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_set()
>{
> if(position == last)
> return false;
> if(static_cast<const re_set*>(pstate)->_map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
> {
> pstate = pstate->next.p;
> ++position;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_jump()
>{
> pstate = static_cast<const re_jump*>(pstate)->alt.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_combining()
>{
> if(position == last)
> return false;
> if(is_combining(traits_inst.translate(*position, icase)))
> return false;
> ++position;
> while((position != last) && is_combining(traits_inst.translate(*position, icase)))
> ++position;
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_soft_buffer_end()
>{
> if(m_match_flags & match_not_eob)
> return false;
> BidiIterator p(position);
> while((p != last) && is_separator(traits_inst.translate(*p, icase)))++p;
> if(p != last)
> return false;
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_restart_continue()
>{
> if(position == search_base)
> {
> pstate = pstate->next.p;
> return true;
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_backstep()
>{
> std::ptrdiff_t maxlen = ::boost::re_detail::distance(search_base, position);
> if(maxlen < static_cast<const re_brace*>(pstate)->index)
> return false;
> std::advance(position, -static_cast<const re_brace*>(pstate)->index);
> pstate = pstate->next.p;
> return true;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>inline bool perl_matcher<BidiIterator, Allocator, traits>::match_assert_backref()
>{
>
> bool result = (*m_presult)[static_cast<const re_brace*>(pstate)->index].matched;
> pstate = pstate->next.p;
> return result;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case()
>{
>
> this->icase = static_cast<const re_case*>(pstate)->icase;
> pstate = pstate->next.p;
> return true;
>}
>
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_any()
>{
>
>
>
>
> const unsigned char* _map = re.get_map();
> while(true)
> {
>
> while((position != last) && !can_start(*position, _map, (unsigned char)mask_any) )
> ++position;
> if(position == last)
> {
>
> if(re.can_be_null())
> return match_prefix();
> break;
> }
>
> if(match_prefix())
> return true;
> if(position == last)
> return false;
> ++position;
> }
> return false;
>
>
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_word()
>{
>
>
>
>
>
> const unsigned char* _map = re.get_map();
> if((m_match_flags & match_prev_avail) || (position != base))
> --position;
> else if(match_prefix())
> return true;
> do
> {
> while((position != last) && traits_inst.isctype(*position, m_word_mask))
> ++position;
> while((position != last) && !traits_inst.isctype(*position, m_word_mask))
> ++position;
> if(position == last)
> break;
>
> if(can_start(*position, _map, (unsigned char)mask_any) )
> {
> if(match_prefix())
> return true;
> }
> if(position == last)
> break;
> } while(true);
> return false;
>
>
>
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_line()
>{
>
> const unsigned char* _map = re.get_map();
> if(match_prefix())
> return true;
> while(position != last)
> {
> while((position != last) && !is_separator(*position))
> ++position;
> if(position == last)
> return false;
> ++position;
> if(position == last)
> {
> if(re.can_be_null() && match_prefix())
> return true;
> return false;
> }
>
> if( can_start(*position, _map, (unsigned char)mask_any) )
> {
> if(match_prefix())
> return true;
> }
> if(position == last)
> return false;
>
> }
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_buf()
>{
> if((position == base) && ((m_match_flags & match_not_bob) == 0))
> return match_prefix();
> return false;
>}
>
>template <class BidiIterator, class Allocator, class traits>
>bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit()
>{
># 875 "/usr/include/boost/regex/v4/perl_matcher_common.hpp" 3 4
> return false;
>}
>
>}
>
>}
># 510 "/usr/include/boost/regex/v4/perl_matcher.hpp" 2 3 4
># 89 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
># 97 "/usr/include/boost/regex/v4/regex.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/instances.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/instances.hpp" 3 4
>namespace boost{
># 75 "/usr/include/boost/regex/v4/instances.hpp" 3 4
>__extension__ extern template class basic_regex< char >;
>
>__extension__ extern template class match_results< const char* >;
>
>
>__extension__ extern template class ::boost::re_detail::perl_matcher<char const *, match_results< const char* >::allocator_type, boost::regex_traits<char > >;
>
>
>
>__extension__ extern template class match_results< std::basic_string<char>::const_iterator >;
>
>
>__extension__ extern template class ::boost::re_detail::perl_matcher< std::basic_string<char>::const_iterator, match_results< std::basic_string<char>::const_iterator >::allocator_type, boost::regex_traits<char > >;
># 102 "/usr/include/boost/regex/v4/instances.hpp" 3 4
>}
># 98 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
># 108 "/usr/include/boost/regex/v4/regex.hpp" 3 4
># 1 "/usr/include/boost/regex/v4/instances.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/instances.hpp" 3 4
>namespace boost{
># 75 "/usr/include/boost/regex/v4/instances.hpp" 3 4
>__extension__ extern template class basic_regex< wchar_t >;
>
>__extension__ extern template class match_results< const wchar_t* >;
>
>
>__extension__ extern template class ::boost::re_detail::perl_matcher<wchar_t const *, match_results< const wchar_t* >::allocator_type, boost::regex_traits<wchar_t > >;
>
>
>
>__extension__ extern template class match_results< std::basic_string<wchar_t>::const_iterator >;
>
>
>__extension__ extern template class ::boost::re_detail::perl_matcher< std::basic_string<wchar_t>::const_iterator, match_results< std::basic_string<wchar_t>::const_iterator >::allocator_type, boost::regex_traits<wchar_t > >;
># 102 "/usr/include/boost/regex/v4/instances.hpp" 3 4
>}
># 109 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
># 128 "/usr/include/boost/regex/v4/regex.hpp" 3 4
>namespace boost{
>
>
>
>
>
>
>
>typedef match_results<const char*> cmatch;
>typedef match_results<std::string::const_iterator> smatch;
>
>typedef match_results<const wchar_t*> wcmatch;
>typedef match_results<std::wstring::const_iterator> wsmatch;
>
>
>}
>
># 1 "/usr/include/boost/regex/v4/regex_match.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/regex_match.hpp" 3 4
>namespace boost{
># 36 "/usr/include/boost/regex/v4/regex_match.hpp" 3 4
>template <class BidiIterator, class Allocator, class charT, class traits>
>bool regex_match(BidiIterator first, BidiIterator last,
> match_results<BidiIterator, Allocator>& m,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> re_detail::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags);
> return matcher.match();
>}
>template <class iterator, class charT, class traits>
>bool regex_match(iterator first, iterator last,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> match_results<iterator> m;
> return regex_match(first, last, m, e, flags | regex_constants::match_any);
>}
>
>
>
>
>
>
>
>template <class charT, class Allocator, class traits>
>inline bool regex_match(const charT* str,
> match_results<const charT*, Allocator>& m,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_match(str, str + traits::length(str), m, e, flags);
>}
>
>template <class ST, class SA, class Allocator, class charT, class traits>
>inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
> match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_match(s.begin(), s.end(), m, e, flags);
>}
>template <class charT, class traits>
>inline bool regex_match(const charT* str,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> match_results<const charT*> m;
> return regex_match(str, str + traits::length(str), m, e, flags | regex_constants::match_any);
>}
>
>template <class ST, class SA, class charT, class traits>
>inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> typedef typename std::basic_string<charT, ST, SA>::const_iterator iterator;
> match_results<iterator> m;
> return regex_match(s.begin(), s.end(), m, e, flags | regex_constants::match_any);
>}
># 340 "/usr/include/boost/regex/v4/regex_match.hpp" 3 4
>}
># 146 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_search.hpp" 1 3 4
># 23 "/usr/include/boost/regex/v4/regex_search.hpp" 3 4
>namespace boost{
>
>
>
>
>
>template <class BidiIterator, class Allocator, class charT, class traits>
>bool regex_search(BidiIterator first, BidiIterator last,
> match_results<BidiIterator, Allocator>& m,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> if(e.flags() & regex_constants::failbit)
> return false;
>
> re_detail::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags);
> return matcher.find();
>}
># 49 "/usr/include/boost/regex/v4/regex_search.hpp" 3 4
>template <class charT, class Allocator, class traits>
>inline bool regex_search(const charT* str,
> match_results<const charT*, Allocator>& m,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_search(str, str + traits::length(str), m, e, flags);
>}
>
>template <class ST, class SA, class Allocator, class charT, class traits>
>inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
> match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_search(s.begin(), s.end(), m, e, flags);
>}
># 117 "/usr/include/boost/regex/v4/regex_search.hpp" 3 4
>template <class BidiIterator, class charT, class traits>
>bool regex_search(BidiIterator first, BidiIterator last,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> if(e.flags() & regex_constants::failbit)
> return false;
>
> match_results<BidiIterator> m;
> typedef typename match_results<BidiIterator>::allocator_type match_alloc_type;
> re_detail::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any);
> return matcher.find();
>}
>
>
>
>template <class charT, class traits>
>inline bool regex_search(const charT* str,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_search(str, str + traits::length(str), e, flags);
>}
>
>template <class ST, class SA, class charT, class traits>
>inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_search(s.begin(), s.end(), e, flags);
>}
># 189 "/usr/include/boost/regex/v4/regex_search.hpp" 3 4
>}
># 149 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_iterator.hpp" 1 3 4
># 24 "/usr/include/boost/regex/v4/regex_iterator.hpp" 3 4
>namespace boost{
>
>
>
>
>
>template <class BidirectionalIterator,
> class charT,
> class traits>
>class regex_iterator_implementation
>{
> typedef basic_regex<charT, traits> regex_type;
>
> match_results<BidirectionalIterator> what;
> BidirectionalIterator base;
> BidirectionalIterator end;
> const regex_type re;
> match_flag_type flags;
>
>public:
> regex_iterator_implementation(const regex_type* p, BidirectionalIterator last, match_flag_type f)
> : base(), end(last), re(*p), flags(f){}
> bool init(BidirectionalIterator first)
> {
> base = first;
> return regex_search(first, end, what, re, flags);
> }
> bool compare(const regex_iterator_implementation& that)
> {
> if(this == &that) return true;
> return (&re.get_data() == &that.re.get_data()) && (end == that.end) && (flags == that.flags) && (what[0].first == that.what[0].first) && (what[0].second == that.what[0].second);
> }
> const match_results<BidirectionalIterator>& get()
> { return what; }
> bool next()
> {
> if(what.prefix().first != what[0].second)
> flags |= match_prev_avail;
> BidirectionalIterator next_start = what[0].second;
> match_flag_type f(flags);
> if(!what.length())
> f |= regex_constants::match_not_initial_null;
> if(base != next_start)
> f |= regex_constants::match_not_bob;
> bool result = regex_search(next_start, end, what, re, f);
> if(result)
> what.set_base(base);
> return result;
> }
>private:
> regex_iterator_implementation& operator=(const regex_iterator_implementation&);
>};
>
>template <class BidirectionalIterator,
> class charT = typename re_detail::regex_iterator_traits<BidirectionalIterator>::value_type,
> class traits = regex_traits<charT> >
>class regex_iterator
>
> : public std::iterator<
> std::forward_iterator_tag,
> match_results<BidirectionalIterator>,
> typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
> const match_results<BidirectionalIterator>*,
> const match_results<BidirectionalIterator>& >
>
>{
>private:
> typedef regex_iterator_implementation<BidirectionalIterator, charT, traits> impl;
> typedef shared_ptr<impl> pimpl;
>public:
> typedef basic_regex<charT, traits> regex_type;
> typedef match_results<BidirectionalIterator> value_type;
> typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type
> difference_type;
> typedef const value_type* pointer;
> typedef const value_type& reference;
> typedef std::forward_iterator_tag iterator_category;
>
> regex_iterator(){}
> regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
> const regex_type& re,
> match_flag_type m = match_default)
> : pdata(new impl(&re, b, m))
> {
> if(!pdata->init(a))
> {
> pdata.reset();
> }
> }
> regex_iterator(const regex_iterator& that)
> : pdata(that.pdata) {}
> regex_iterator& operator=(const regex_iterator& that)
> {
> pdata = that.pdata;
> return *this;
> }
> bool operator==(const regex_iterator& that)const
> {
> if((pdata.get() == 0) || (that.pdata.get() == 0))
> return pdata.get() == that.pdata.get();
> return pdata->compare(*(that.pdata.get()));
> }
> bool operator!=(const regex_iterator& that)const
> { return !(*this == that); }
> const value_type& operator*()const
> { return pdata->get(); }
> const value_type* operator->()const
> { return &(pdata->get()); }
> regex_iterator& operator++()
> {
> cow();
> if(0 == pdata->next())
> {
> pdata.reset();
> }
> return *this;
> }
> regex_iterator operator++(int)
> {
> regex_iterator result(*this);
> ++(*this);
> return result;
> }
>private:
>
> pimpl pdata;
>
> void cow()
> {
>
> if(pdata.get() && !pdata.unique())
> {
> pdata.reset(new impl(*(pdata.get())));
> }
> }
>};
>
>typedef regex_iterator<const char*> cregex_iterator;
>typedef regex_iterator<std::string::const_iterator> sregex_iterator;
>
>typedef regex_iterator<const wchar_t*> wcregex_iterator;
>typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
>
>
>
>template <class charT, class traits>
>inline regex_iterator<const charT*, charT, traits> make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, m);
>}
>template <class charT, class traits, class ST, class SA>
>inline regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, m);
>}
>
>
>
>
>
>}
># 152 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_token_iterator.hpp" 1 3 4
># 37 "/usr/include/boost/regex/v4/regex_token_iterator.hpp" 3 4
>namespace boost{
># 47 "/usr/include/boost/regex/v4/regex_token_iterator.hpp" 3 4
>template <class BidirectionalIterator,
> class charT,
> class traits>
>class regex_token_iterator_implementation
>{
> typedef basic_regex<charT, traits> regex_type;
> typedef sub_match<BidirectionalIterator> value_type;
>
> match_results<BidirectionalIterator> what;
> BidirectionalIterator end;
> const regex_type re;
> match_flag_type flags;
> value_type result;
> int N;
> std::vector<int> subs;
>
>public:
> regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, int sub, match_flag_type f)
> : end(last), re(*p), flags(f){ subs.push_back(sub); }
> regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const std::vector<int>& v, match_flag_type f)
> : end(last), re(*p), flags(f), subs(v){}
># 86 "/usr/include/boost/regex/v4/regex_token_iterator.hpp" 3 4
> template <std::size_t CN>
> regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const int (&submatches)[CN], match_flag_type f)
> : end(last), re(*p), flags(f)
> {
> for(std::size_t i = 0; i < CN; ++i)
> {
> subs.push_back(submatches[i]);
> }
> }
>
>
> bool init(BidirectionalIterator first)
> {
> N = 0;
> if(regex_search(first, end, what, re, flags) == true)
> {
> N = 0;
> result = ((subs[N] == -1) ? what.prefix() : what[(int)subs[N]]);
> return true;
> }
> else if((subs[N] == -1) && (first != end))
> {
> result.first = first;
> result.second = end;
> result.matched = (first != end);
> return true;
> }
> return false;
> }
> bool compare(const regex_token_iterator_implementation& that)
> {
> if(this == &that) return true;
> return (&re.get_data() == &that.re.get_data())
> && (end == that.end)
> && (flags == that.flags)
> && (N == that.N)
> && (what[0].first == that.what[0].first)
> && (what[0].second == that.what[0].second);
> }
> const value_type& get()
> { return result; }
> bool next()
> {
> if(N == -1)
> return false;
> if(N+1 < (int)subs.size())
> {
> ++N;
> result =((subs[N] == -1) ? what.prefix() : what[subs[N]]);
> return true;
> }
> if(what.prefix().first != what[0].second)
> flags |= match_prev_avail | regex_constants::match_not_bob;
> BidirectionalIterator last_end(what[0].second);
> if(regex_search(last_end, end, what, re, ((what[0].first == what[0].second) ? flags | regex_constants::match_not_initial_null : flags)))
> {
> N =0;
> result =((subs[N] == -1) ? what.prefix() : what[subs[N]]);
> return true;
> }
> else if((last_end != end) && (subs[0] == -1))
> {
> N =-1;
> result.first = last_end;
> result.second = end;
> result.matched = (last_end != end);
> return true;
> }
> return false;
> }
>private:
> regex_token_iterator_implementation& operator=(const regex_token_iterator_implementation&);
>};
>
>template <class BidirectionalIterator,
> class charT = typename re_detail::regex_iterator_traits<BidirectionalIterator>::value_type,
> class traits = regex_traits<charT> >
>class regex_token_iterator
>
> : public std::iterator<
> std::forward_iterator_tag,
> sub_match<BidirectionalIterator>,
> typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
> const sub_match<BidirectionalIterator>*,
> const sub_match<BidirectionalIterator>& >
>
>{
>private:
> typedef regex_token_iterator_implementation<BidirectionalIterator, charT, traits> impl;
> typedef shared_ptr<impl> pimpl;
>public:
> typedef basic_regex<charT, traits> regex_type;
> typedef sub_match<BidirectionalIterator> value_type;
> typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type
> difference_type;
> typedef const value_type* pointer;
> typedef const value_type& reference;
> typedef std::forward_iterator_tag iterator_category;
>
> regex_token_iterator(){}
> regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
> int submatch = 0, match_flag_type m = match_default)
> : pdata(new impl(&re, b, submatch, m))
> {
> if(!pdata->init(a))
> pdata.reset();
> }
> regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
> const std::vector<int>& submatches, match_flag_type m = match_default)
> : pdata(new impl(&re, b, submatches, m))
> {
> if(!pdata->init(a))
> pdata.reset();
> }
># 214 "/usr/include/boost/regex/v4/regex_token_iterator.hpp" 3 4
> template <std::size_t N>
> regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
> const int (&submatches)[N], match_flag_type m = match_default)
> : pdata(new impl(&re, b, submatches, m))
> {
> if(!pdata->init(a))
> pdata.reset();
> }
>
>
> regex_token_iterator(const regex_token_iterator& that)
> : pdata(that.pdata) {}
> regex_token_iterator& operator=(const regex_token_iterator& that)
> {
> pdata = that.pdata;
> return *this;
> }
> bool operator==(const regex_token_iterator& that)const
> {
> if((pdata.get() == 0) || (that.pdata.get() == 0))
> return pdata.get() == that.pdata.get();
> return pdata->compare(*(that.pdata.get()));
> }
> bool operator!=(const regex_token_iterator& that)const
> { return !(*this == that); }
> const value_type& operator*()const
> { return pdata->get(); }
> const value_type* operator->()const
> { return &(pdata->get()); }
> regex_token_iterator& operator++()
> {
> cow();
> if(0 == pdata->next())
> {
> pdata.reset();
> }
> return *this;
> }
> regex_token_iterator operator++(int)
> {
> regex_token_iterator result(*this);
> ++(*this);
> return result;
> }
>private:
>
> pimpl pdata;
>
> void cow()
> {
>
> if(pdata.get() && !pdata.unique())
> {
> pdata.reset(new impl(*(pdata.get())));
> }
> }
>};
>
>typedef regex_token_iterator<const char*> cregex_token_iterator;
>typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
>
>typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
>typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
>
>
>template <class charT, class traits>
>inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
>}
>template <class charT, class traits, class ST, class SA>
>inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
>}
>
>template <class charT, class traits, std::size_t N>
>inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
>}
>template <class charT, class traits, class ST, class SA, std::size_t N>
>inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
>}
>
>template <class charT, class traits>
>inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
>}
>template <class charT, class traits, class ST, class SA>
>inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
>{
> return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
>}
># 319 "/usr/include/boost/regex/v4/regex_token_iterator.hpp" 3 4
>}
># 155 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_grep.hpp" 1 3 4
># 23 "/usr/include/boost/regex/v4/regex_grep.hpp" 3 4
>namespace boost{
># 33 "/usr/include/boost/regex/v4/regex_grep.hpp" 3 4
>template <class Predicate, class BidiIterator, class charT, class traits>
>inline unsigned int regex_grep(Predicate foo,
> BidiIterator first,
> BidiIterator last,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> if(e.flags() & regex_constants::failbit)
> return false;
>
> typedef typename match_results<BidiIterator>::allocator_type match_allocator_type;
>
> match_results<BidiIterator> m;
> re_detail::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags);
> unsigned int count = 0;
> while(matcher.find())
> {
> ++count;
> if(0 == foo(m))
> return count;
> if(m[0].second == last)
> return count;
> if(m.length() == 0)
> {
> if(m[0].second == last)
> return count;
>
>
> match_results<BidiIterator, match_allocator_type> m2(m);
> matcher.setf(match_not_null | match_continuous);
> if(matcher.find())
> {
> ++count;
> if(0 == foo(m))
> return count;
> }
> else
> {
>
> m = m2;
> }
> matcher.unsetf((match_not_null | match_continuous) & ~flags);
> }
> }
> return count;
>}
># 87 "/usr/include/boost/regex/v4/regex_grep.hpp" 3 4
>template <class Predicate, class charT, class traits>
>inline unsigned int regex_grep(Predicate foo, const charT* str,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_grep(foo, str, str + traits::length(str), e, flags);
>}
>
>template <class Predicate, class ST, class SA, class charT, class traits>
>inline unsigned int regex_grep(Predicate foo, const std::basic_string<charT, ST, SA>& s,
> const basic_regex<charT, traits>& e,
> match_flag_type flags = match_default)
>{
> return regex_grep(foo, s.begin(), s.end(), e, flags);
>}
># 138 "/usr/include/boost/regex/v4/regex_grep.hpp" 3 4
>}
># 158 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_replace.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/regex_replace.hpp" 3 4
>namespace boost{
>
>
>
>
>
>template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
>OutputIterator regex_replace(OutputIterator out,
> BidirectionalIterator first,
> BidirectionalIterator last,
> const basic_regex<charT, traits>& e,
> const charT* fmt,
> match_flag_type flags = match_default)
>{
> regex_iterator<BidirectionalIterator, charT, traits> i(first, last, e, flags);
> regex_iterator<BidirectionalIterator, charT, traits> j;
> if(i == j)
> {
> if(!(flags & regex_constants::format_no_copy))
> out = re_detail::copy(first, last, out);
> }
> else
> {
> BidirectionalIterator last_m = first;
> while(i != j)
> {
> if(!(flags & regex_constants::format_no_copy))
> out = re_detail::copy(i->prefix().first, i->prefix().second, out);
> out = i->format(out, fmt, flags, e);
> last_m = (*i)[0].second;
> if(flags & regex_constants::format_first_only)
> break;
> ++i;
> }
> if(!(flags & regex_constants::format_no_copy))
> out = re_detail::copy(last_m, last, out);
> }
> return out;
>}
>
>template <class OutputIterator, class Iterator, class traits, class charT>
>inline OutputIterator regex_replace(OutputIterator out,
> Iterator first,
> Iterator last,
> const basic_regex<charT, traits>& e,
> const std::basic_string<charT>& fmt,
> match_flag_type flags = match_default)
>{
> return regex_replace(out, first, last, e, fmt.c_str(), flags);
>}
>
>template <class traits, class charT>
>std::basic_string<charT> regex_replace(const std::basic_string<charT>& s,
> const basic_regex<charT, traits>& e,
> const charT* fmt,
> match_flag_type flags = match_default)
>{
> std::basic_string<charT> result;
> re_detail::string_out_iterator<std::basic_string<charT> > i(result);
> regex_replace(i, s.begin(), s.end(), e, fmt, flags);
> return result;
>}
>
>template <class traits, class charT>
>std::basic_string<charT> regex_replace(const std::basic_string<charT>& s,
> const basic_regex<charT, traits>& e,
> const std::basic_string<charT>& fmt,
> match_flag_type flags = match_default)
>{
> std::basic_string<charT> result;
> re_detail::string_out_iterator<std::basic_string<charT> > i(result);
> regex_replace(i, s.begin(), s.end(), e, fmt.c_str(), flags);
> return result;
>}
>
>
>
>
>
>}
># 161 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_merge.hpp" 1 3 4
># 25 "/usr/include/boost/regex/v4/regex_merge.hpp" 3 4
>namespace boost{
>
>
>
>
>
>template <class OutputIterator, class Iterator, class traits, class charT>
>inline OutputIterator regex_merge(OutputIterator out,
> Iterator first,
> Iterator last,
> const basic_regex<charT, traits>& e,
> const charT* fmt,
> match_flag_type flags = match_default)
>{
> return regex_replace(out, first, last, e, fmt, flags);
>}
>
>template <class OutputIterator, class Iterator, class traits, class charT>
>inline OutputIterator regex_merge(OutputIterator out,
> Iterator first,
> Iterator last,
> const basic_regex<charT, traits>& e,
> const std::basic_string<charT>& fmt,
> match_flag_type flags = match_default)
>{
> return regex_merge(out, first, last, e, fmt.c_str(), flags);
>}
>
>template <class traits, class charT>
>inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
> const basic_regex<charT, traits>& e,
> const charT* fmt,
> match_flag_type flags = match_default)
>{
> return regex_replace(s, e, fmt, flags);
>}
>
>template <class traits, class charT>
>inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
> const basic_regex<charT, traits>& e,
> const std::basic_string<charT>& fmt,
> match_flag_type flags = match_default)
>{
> return regex_replace(s, e, fmt, flags);
>}
>
>
>
>
>
>}
># 164 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_split.hpp" 1 3 4
># 24 "/usr/include/boost/regex/v4/regex_split.hpp" 3 4
>namespace boost{
>
>
>
>
>
>namespace re_detail{
>
>template <class charT>
>const basic_regex<charT>& get_default_expression(charT)
>{
> static const charT expression_text[4] = { '\\', 's', '+', '\00', };
> static const basic_regex<charT> e(expression_text);
> return e;
>}
>
>template <class OutputIterator, class charT, class Traits1, class Alloc1>
>class split_pred
>{
> typedef std::basic_string<charT, Traits1, Alloc1> string_type;
> typedef typename string_type::const_iterator iterator_type;
> iterator_type* p_last;
> OutputIterator* p_out;
> std::size_t* p_max;
> std::size_t initial_max;
>public:
> split_pred(iterator_type* a, OutputIterator* b, std::size_t* c)
> : p_last(a), p_out(b), p_max(c), initial_max(*c) {}
>
> bool operator()(const match_results<iterator_type>& what);
>};
>
>template <class OutputIterator, class charT, class Traits1, class Alloc1>
>bool split_pred<OutputIterator, charT, Traits1, Alloc1>::operator()
> (const match_results<iterator_type>& what)
>{
> *p_last = what[0].second;
> if(what.size() > 1)
> {
>
> for(unsigned i = 1; i < what.size(); ++i)
> {
> *(*p_out) = what.str(i);
> ++(*p_out);
> if(0 == --*p_max) return false;
> }
> return *p_max != 0;
> }
> else
> {
>
> const sub_match<iterator_type>& sub = what[-1];
> if((sub.first != sub.second) || (*p_max != initial_max))
> {
> *(*p_out) = sub.str();
> ++(*p_out);
> return --*p_max;
> }
> }
>
>
> return true;
>}
>
>}
>
>template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
>std::size_t regex_split(OutputIterator out,
> std::basic_string<charT, Traits1, Alloc1>& s,
> const basic_regex<charT, Traits2>& e,
> match_flag_type flags,
> std::size_t max_split)
>{
> typedef typename std::basic_string<charT, Traits1, Alloc1>::const_iterator ci_t;
> typedef typename match_results<ci_t>::allocator_type match_allocator;
> ci_t last = s.begin();
> std::size_t init_size = max_split;
> re_detail::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split);
> ci_t i, j;
> i = s.begin();
> j = s.end();
> regex_grep(pred, i, j, e, flags);
>
>
>
>
> if(max_split && (last != s.end()) && (e.mark_count() == 1))
> {
> *out = std::basic_string<charT, Traits1, Alloc1>((ci_t)last, (ci_t)s.end());
> ++out;
> last = s.end();
> --max_split;
> }
>
>
> s.erase(0, last - s.begin());
>
>
> return init_size - max_split;
>}
>
>template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
>inline std::size_t regex_split(OutputIterator out,
> std::basic_string<charT, Traits1, Alloc1>& s,
> const basic_regex<charT, Traits2>& e,
> match_flag_type flags = match_default)
>{
> return regex_split(out, s, e, flags, (2147483647 * 2U + 1U));
>}
>
>template <class OutputIterator, class charT, class Traits1, class Alloc1>
>inline std::size_t regex_split(OutputIterator out,
> std::basic_string<charT, Traits1, Alloc1>& s)
>{
> return regex_split(out, s, re_detail::get_default_expression(charT(0)), match_default, (2147483647 * 2U + 1U));
>}
>
>
>
>
>
>}
># 167 "/usr/include/boost/regex/v4/regex.hpp" 2 3 4
># 32 "/usr/include/boost/regex.hpp" 2 3 4
># 45 "aiLex.h" 2
># 1 "Bstring.h" 1
># 19 "Bstring.h"
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 1 3
># 46 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
> 
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 3
>
># 1 "/usr/include/assert.h" 1 3 4
># 65 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (__const char *__assertion, __const char *__file,
> unsigned int __line, __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, __const char *__file,
> unsigned int __line,
> __const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 49 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cassert" 2 3
># 20 "Bstring.h" 2
>
>
>
>class Bstring;
>
>
>inline double square (double x) {return x*x;}
># 35 "Bstring.h"
>inline bool striEq (const char* x, const char* y) {return strcasecmp( x, y) == 0;}
>inline bool strEq (const char* x, const char* y) {return strcmp( x, y) == 0;}
>inline bool memEq (const char* x, const char* y, int len) {
> return memcmp( x, y, len) == 0;}
>inline bool preFix (char** bp, const char* key, int len= 3) {
> if (! memEq( key, *bp, len)) return false;
> *bp += len;
> return true;
>}
># 57 "Bstring.h"
>class Bstring : public std::string
>{
>public:
> Bstring () : std::string() {}
> Bstring (const char * s) : std::string(s) {}
> Bstring (const std::string& s) : std::string(s) {}
> Bstring (const Bstring& s) : std::string(s) {}
> Bstring (const Bstring& s, int pos, int len) : std::string(s,pos,len) {}
>
> bool extract (Bstring& dest, const boost::regex& rx) const;
> bool extract (Bstring& dest, const char* pat) const;
> bool extract (Bstring& one, Bstring& two, const boost::regex& rx) const;
> Bstring right(size_t len) const {return substr( size()-len, len);}
> void mid (char* dest, size_t start, size_t length) const;
> void mid (char* dest, size_t start) const;
> void mid (char* dest) const;
> char last () const {return (*this)[ size()-1];}
> char& last () {return (*this)[ size()-1];}
> void insert (const char* s) {std::string::insert( 0 , s);}
> void insert (size_t pos, const char* s) {std::string::insert( pos, s);}
> void insert (size_t pos, const Bstring& s) {std::string::insert( pos, s);}
> bool match (const char * s) const;
> bool match (const Bstring& s) const {return match( s.c_str());}
> bool match (const boost::regex& rx) const;
> bool search (const char * s) const;
> bool search (const Bstring& s) const {return search( s.c_str());}
> bool search (const boost::regex& rx) const;
> void replace (const Bstring& old, const char * nue);
> void replace (const Bstring& old, const Bstring& nue) {
> return replace( old, nue.c_str());}
> void replace (const boost::regex& rx, const Bstring& nue);
> void replace (const boost::regex& rx, const char * nue);
> void replaceUnder ();
> void replaceWord (const Bstring& old, const char* nue);
> void replaceWord (const Bstring& old, const Bstring& nue) {
> return replaceWord( old, nue.c_str());}
> void changeFromClient ();
> void changeToClient ();
> void deQuote ();
> void evalExpr ();
> void evalPercent();
> bool evalUser ();
> void evalVars ();
> void evalWords ();
> int getValue (const boost::regex rx);
> void sentenceCase ();
> void split (Bstring& tail);
> void trim ();
>
> bool begins (int vmx, const char* verb);
> bool starts (const char* verb, int vmx) const {
> return memEq( c_str(), verb, vmx);}
> int cmp (const char * rhs) {return strcasecmp( c_str(), rhs);}
> bool operator< (const char * rhs) {return cmp( rhs ) < 0;}
> bool operator< (const std::string& rhs) {return cmp( rhs.c_str()) < 0;}
> bool operator< (const Bstring& rhs) {return cmp( rhs.c_str()) < 0;}
> bool operator== (const char * rhs) {return cmp( rhs ) == 0;}
> bool operator== (const std::string& rhs) {return cmp( rhs.c_str()) == 0;}
> bool operator== (const Bstring& rhs) {return cmp( rhs.c_str()) == 0;}
> bool operator<= (const Bstring& rhs) {return cmp( rhs.c_str()) <= 0;}
> Bstring& operator<< (const double& v);
> Bstring& operator<< (const int & v);
> Bstring& operator<< (const char & c) {operator+=(c); return *this;}
> Bstring& operator<< (const char * s) {operator+=(s); return *this;}
> Bstring& operator<< (const Bstring&b) {operator+=(b); return *this;}
> Bstring& operator>> (double& dest);
> Bstring& operator>> (int & dest);
> Bstring& operator>> (char & dest);
>
>
>
> static const int npos = std::string::npos;
> static const Bstring white;
>};
>
>inline void Bstring::mid (char* dest) const {
>
> strcpy( dest, c_str());
>}
>inline void Bstring::mid (char* dest, size_t start) const {
> strcpy( dest, c_str()+start);
>}
>inline void Bstring::mid (char* dest, size_t start, size_t len) const {
> if (len > size() - start) len= size() - start;
> *(char *)mempcpy( dest, c_str(), len) = 0;
>}
># 155 "Bstring.h"
> inline double uniFrand () {return drand48();}
>
>
>
>inline int randInt (int top) {return int( top * uniFrand());}
>
>
>
>
>
>
>typedef std::vector< Bstring> Seqp;
>
>void append (Seqp& dest, const Seqp& from);
>template <class T> T choose (const Seqp& from);
>template <class T> T join (const Seqp& from, const char* separator= " ");
>template <class T>
>void split(Seqp& dest,const T& from,const Bstring& delimiters= Bstring::white);
>std::ostream& operator<< (std::ostream& out, const Seqp& from);
># 46 "aiLex.h" 2
>class Alice;
>class BrainFile;
>class Bstring;
>class Glossary;
>class Query;
>class UxType;
># 66 "aiLex.h"
>class xCept
>{
> xCept ();
>protected:
> const char* const s;
>public:
> xCept (const char *why) : s(why) {}
> xCept (const xCept& x ) : s(x.s) {}
>
> const char* why () const {return s;}
> ~xCept() {}
>};
>
>class xCeptV : public xCept
>{
>public:
> xCeptV (const char *msg);
> ~xCeptV();
>};
>
>class xCeptAbend : public xCept
>{
>public:
> xCeptAbend () : xCept(0) {}
> ~xCeptAbend() {}
>};
>
>class xCeptSignal : public xCept
>{
>public:
> xCeptSignal () : xCept(0) {}
> ~xCeptSignal() {}
>};
>
>
>typedef std::map< Bstring, Bstring> Dict;
>typedef std::map< Bstring, int> Assoc;
>typedef std::map< Bstring, int> WordFreq;
>
>
>
>
>
>
>double dble (Bstring::iterator& source, Bstring::const_iterator seof)
> throw (xCept);
>
>
>
>
>typedef int Cite;
>typedef std::map< Cite, int> CiteFreq;
>const int citeNone = -1;
>const int citeEmpty = 0;
>const int citeWhat = 1;
>
>class CiteList
>{
> typedef std::vector< Cite> Citations;
> Citations alts;
> void multi ();
>public:
> CiteList () : alts() {}
> CiteList (const Bstring& s);
>
> void add (Cite another) {alts.push_back( another);}
> void add (const CiteList& more);
> void clear () {alts.clear();}
> bool find (Cite target) const;
> Cite front () const {return alts.front();}
> bool empty () const {return alts.empty();}
> size_t size () const {return alts.size();}
>
> Bstring toStr (int start= 0, const Bstring& sep= " ") const;
> double philtre (const CiteList& source);
> void show () const;
> typedef Citations::const_iterator const_iterator;
> const_iterator begin () const {return alts.begin();}
> const_iterator end () const {return alts.end ();}
>};
>
>
>
>
>
>
>class Signature
>{
> typedef std::set< Cite> SigSet;
> SigSet guts;
>public:
> Signature () : guts() {}
> Signature (const Signature& x);
> Signature (const Cite & c) : guts() {add( c);}
> Signature (const CiteList & f) : guts() {add( f);}
> Signature (const Bstring & s);
> Signature operator* (const Signature& rhs) const;
> void add (Cite another);
> void add (const CiteList & more);
> void add (const Signature& more);
> void addAll(const Bstring & line);
>
> void clear () {guts.clear();}
> bool has (const Cite& x) const {return guts.find( x) != guts.end();}
> bool has (const CiteList & x) const;
> bool match (const Signature& rhs) const;
> bool empty () const {return guts.empty();}
> size_t size () const {return guts.size();}
>
> Bstring toStr () const;
> typedef SigSet::const_iterator const_iterator;
> const_iterator begin () const {return guts.begin();}
> const_iterator end () const {return guts.end ();}
>};
>
>
>
>class Query
>{
> Signature base;
> Signature alts;
> bool searchMany;
> double expand (const Bstring& msg);
>public:
> Bstring msg;
> bool checkName;
> Query () {}
> ~Query() {}
> bool inferringAllowed;
> void searchAll (bool x) {searchMany = x;}
> bool searchAll () const {return searchMany;}
> void select () const;
> size_t size () const {return base.size();}
> Bstring toStr () const {return base.toStr();}
> double open (const Bstring& msg, bool wantName= false);
> double add (const Bstring& msg);
> double like (const Signature& fSign) const;
>};
># 212 "aiLex.h"
>class Loadable
>{
> friend class Provenance;
>protected:
> Bstring comment;
> int section;
> int priority;
> bool dirty;
>public:
> const char* me;
> Loadable (const char* who, const char* what= "");
> virtual ~Loadable();
> int open ();
> void done ();
>
> virtual void add (const Bstring& f) =0;
> virtual bool empty () const =0;
> virtual size_t size () const =0;
> virtual void write (FILE* sv);
>};
># 242 "aiLex.h"
>class Phrase
>{
> friend class Glossary;
> const char* w;
> std::set< int > ourFacts;
> Signature* ourGang;
> size_t frequency;
> Cite self;
> int len;
> bool proper;
>
>
>
>public:
> Phrase ();
> ~Phrase();
> Phrase (const Phrase& p);
> void operator= (const Phrase& p);
> const Signature& gang () const;
> const char* s() const {return w;}
> size_t size () const {return len;}
> bool empty () const {return len == 0;}
> size_t occurs() const {return frequency;}
>};
>
>
>class IgQuoteLess
>{
>public:
> bool operator() (const Bstring& a, const Bstring& b) const;
>};
>
>class IgCaseLess
>{
>public:
> bool operator() (const Bstring& a, const Bstring& b) const {
> return strcasecmp( a.c_str(), b.c_str()) < 0;
> }
>};
>
>
>
>class Glossary : public Loadable
>{
> std::vector< Phrase> data;
> std::map< Bstring, int, IgCaseLess> dict;
>public:
>
> Glossary ();
> ~Glossary();
> void init ();
> Cite addWord (const char* s);
> void addAll (const Bstring& s);
> void add (const Bstring& s);
>
> void add (const char* w, const CiteList& syn);
> void refBy (Cite index, int aFact) {data[ index].ourFacts.insert( aFact);}
> void open ();
> void done ();
> bool empty () const {return data.empty();}
> size_t size () const {return data.size();}
> const char* get (const Cite index) const {return data[ index].w;}
> const Phrase& phrase (const Cite index) const {return data[ index];}
>
> size_t occurs (const Cite index) const {return data[ index].frequency;}
> const Signature& gang (const Cite index) const;
> Cite find (const char* x) const;
> Cite lookup (const char* x);
> Cite lookup (const Bstring& s) {return lookup( s.c_str());}
> Cite find (const Bstring& s) const {return find( s.c_str());}
>};
># 322 "aiLex.h"
>template <typename T>
>class History
>{
> int in, ot, lim;
> std::vector< T> data;
> const char* who;
> History ();
> size_t size() const;
>public:
> History (int bound, const char* name="")
> : data( bound+1), lim( bound), in(0), ot(0), who(name) {}
> History (const History<T>& rhs);
> const T& top () const {return data[ in];}
> const T& oldest () const {return data[ ot];}
> const char* name() const {return who;}
> bool empty () const {return in == ot;}
> bool full () const {int no= ot <= 0? lim : ot; return no-1 == in;}
> bool __attribute__((stdcall)) contains (const T& target) const;
> Bstring toString () const;
> void clear () {
> data.clear(); in= ot= 0;}
> void push (const T& valu) {
> data[ in] = valu;
> if (++in >= lim) in= 0;
> if (in == ot && ++ot >= lim) ot= 0;
> }
> void pop () {
> if (empty()) throw xCept("history underflow");
> else if (--in < 0) in= lim-1;
> }
>
>
> void put (const T& v) {
> if (ot <= 0) ot= lim;
> if (--ot == in) throw xCept("history overflow");
> data[ot] = v;
> }
>
>
>
> class const_iterator
> {
> const History<T>& us;
> int where;
> void operator-- () {if (++where >= us.lim) where= 0;}
> public:
> const_iterator (const History<T>& dad, int index)
> : us( dad), where( index) {};
> void operator++ () {if (where <= 0) where= us.lim; --where;}
> bool operator!= (const const_iterator& rhs) const {
> return !(*this == rhs);}
> bool operator== (const const_iterator& rhs) const {
> return where == rhs.where;}
> const T* operator->() const {return &us.data[ where];}
> const T& operator* () const {return us.data[ where];}
> T& operator* () {return us.data[ where];}
> };
> const_iterator begin()const{return const_iterator(*this,(in <= 0?lim:in)-1);}
> const_iterator end ()const{return const_iterator(*this,(ot <= 0?lim:ot)-1);}
>};
>
>
>
>
>
>
>class Remover
>{
> boost::regex rxPat;
>
>
> friend void initFroler();
>public:
> Remover () {}
> ~Remover() {}
> void execute (Bstring& dest) const;
> bool in (const Bstring& msg) const;
> bool contains (const Bstring& word) const {return in( word);}
> void init (const char* text);
>};
>
>
>
>class RemoveSet
>{
> std::set< Bstring> targets;
> friend void initFroler();
>public:
> RemoveSet () {}
> ~RemoveSet() {}
> void execute (Bstring& dest) const;
> bool in (const Bstring& msg) const;
> bool contains (const Bstring& word) const {
> return targets.find( word) != targets.end();}
>
> void init (const char* text, bool wordOnly= true);
> size_t size () const {return targets.size();}
>};
>
>
>
>
>
>class Roler : public Loadable
>{
> std::vector< boost::regex* > old;
> std::vector< Bstring> nue;
>public:
> Roler (const char* who) : Loadable( who) {}
> ~Roler() {}
>
> void add (const Bstring& o, const Bstring& n);
> void add (const Bstring& s);
> void open ();
> void done ();
> void dsub (Bstring& s) const;
>
> bool empty () const {return old.empty();}
> size_t size () const {return old.size();}
>};
>
>
>
>
>
>
>
>class Nouns : public Loadable
>{
> typedef std::map< Bstring, Bstring> ANoun;
> ANoun data;
>public:
> Nouns (const char* who) : Loadable( who), data() {}
> ~Nouns() {}
> void add (const Bstring& s);
> void add (const Bstring& var, const Bstring& valu);
> void open ();
> bool empty () const {return data.empty();}
> size_t size () const {return data.size();}
> typedef ANoun::const_iterator const_iterator;
> const_iterator begin () const {return data.begin();}
> const_iterator end () const {return data.end ();}
> const_iterator find (const char* w) const;
>};
>
>
>
>class Affector : public Loadable
>{
> typedef std::map< Bstring, int, IgCaseLess> Elicit;
> Elicit affect;
> Bstring curHead;
>public:
> Affector (const char* who) : Loadable( who), affect() {}
> ~Affector() {}
> void add (const Bstring& s);
> void open ();
> void sense (int dest[], const Bstring& msg) const;
> bool empty () const {return affect.empty();}
> size_t size () const {return affect.size();}
>};
>
>
>class Effect : public Loadable
>{
> typedef std::pair< const boost::regex*, const char*> Element;
> typedef std::vector< Element> Elicit;
> Elicit effect;
> const char* curHead;
>public:
> Effect (const char* who) : Loadable( who), effect() {}
> ~Effect() {}
> void add (const Bstring& s);
> void open ();
> void sense (Bstring& dest, const Bstring& msg) const;
> bool empty () const {return effect.empty();}
> size_t size () const {return effect.size();}
>};
># 512 "aiLex.h"
>class Agenda : public Loadable
>{
> std::vector< Bstring> data;
>public:
> Agenda (const char* who, const char* what= "");
> ~Agenda ();
> void add (const Bstring& s);
> void done ();
> bool empty () const {return data.empty();}
> size_t size () const {return data.size();}
> void pare (Agenda& newer, const time_t mark);
> void sort () {std::sort( data.begin(), data.end());}
> void write (FILE* sv);
> typedef std::vector< Bstring>::const_iterator const_iterator;
> const_iterator begin () const {return data.begin();}
> const_iterator end () const {return data.end ();}
> const_iterator find (const char* w) const;
> void erase (const_iterator *at);
>};
>
>
>
>
>struct Provenance
>{
> Loadable* who;
> int brain;
> int ordinal;
> int priority;
>public:
> Provenance (int b, int ord, Loadable* us);
>};
>
>
>
>
>class FactBag;
>typedef std::pair< FactBag*, int> FactRef;
>const int factNone = 0;
>const int factAll = ~0;
>extern int theBeat;
>
>class FactBag : public Loadable
>{
> std::vector< Bstring> gloss;
> std::vector< Signature> meat;
> std::vector< int> from;
> std::vector< int> priority;
> std::vector< int> lastBeat;
> int factDial;
>public:
> FactBag (const char* who, const char* what= "");
> ~FactBag();
> static void compile ();
> void add (const Bstring& s);
> void init ();
> void open ();
> void done ();
> void write (FILE* sv);
> void frequency (WordFreq& wf) const;
> bool empty () const {return gloss.empty();}
> size_t size () const {return gloss.size();}
> double recency (int aFact);
> void use (int who) {lastBeat[who] = theBeat;}
> void getMatch (double relate, const Bstring& target);
> void getMatch (double relate, const boost::regex& pattern);
> void getRelevant (double heft, const Query& need);
> int rand ();
> int source (int x) const {return from [ x];}
> const Signature& sign (int x) const {return meat [ x];}
> const Bstring& get (int x) const {return gloss[ x];}
> const Bstring& getRand();
> void resetScan () {factDial= 0;}
> const int next () {
> const int x = factDial;
> if (++factDial >= size()) factDial= 0;
> return x;
> }
>
>
>
>
>
>
>
>};
>
>
>typedef Bstring wordT;
>typedef std::vector< wordT> wList;
>class CharBag;
>
>class TokList
>{
> wList words;
>public:
> TokList () {}
> TokList (const TokList& rhs, int pos);
> TokList (const Bstring& s) {append(s);}
> TokList (int patternNdx) {append( patternNdx);}
> void add (const Bstring& s) {words.push_back( s);}
> void append (const Bstring& p);
> void append (int patternNdx);
> void append (const CharBag& rhs);
> void operator+= (const Bstring& s) {add( s);}
> void operator+= (const char* s) {add( s);}
> void operator+= (const CharBag& rhs) {append( rhs);}
> void flat (Bstring& dest) const;
> void show (const char* pfx= "") const;
> wordT& first () {return words.front();}
> size_t size () const {return words.size();}
> bool empty () const {return words.size() <= 0;}
> wList::const_iterator begin () const {return words.begin();}
> wList::const_iterator end () const {return words.end ();}
>};
>
>
>
>
>class TextAt
>{
> TextAt (): at(0), len(0) {}
>protected:
> int at, len;
>public:
> TextAt (int p, int x) : at( p), len(x) {}
> ~TextAt () {}
> int pos () const {return at;}
> int size () const {return len;}
> std::pair<int,int> seg () const {return std::pair<int,int>( at, len);}
>};
>
>
>class TextPos : public TextAt
>{
>public:
> TextPos () : TextAt(0,0) {}
> TextPos (int pos, int last) : TextAt( pos, last) {}
> ~TextPos () {}
> int pos () const {return at;}
> int last () const {return len;}
>};
>
>
>
>
>
>class CharBag
>{
>protected:
> const Bstring* base;
> std::vector< TextAt> sigs;
>public:
> CharBag (const Bstring& b);
> void __attribute__((stdcall)) addTok (int p, int x);
> int __attribute__((stdcall)) cmp (int j, const char* s) const;
> bool eqp (int t, const char* s) const {return cmp( t, s)==0;}
> int __attribute__((stdcall)) get (int t, int k) const;
> void __attribute__((stdcall)) get (int m, Bstring& dest) const;
> std::pair< const char*, int> get( int t) const;
> size_t __attribute__((stdcall)) getSize (int m) const {return sigs[ m].size();}
> void __attribute__((stdcall)) flat (Bstring& dest) const;
> void __attribute__((stdcall)) show (const char* pfx= "") const;
>
> const char* CharBag::word (int t) const;
> int first () const {return (*base)[0];}
> size_t size () const {return sigs.size();}
> bool empty () const {return sigs.size() <= 0;}
> const TextAt& operator[] (int index) const {return sigs[ index];}
> const TextAt& at (int index) const {return sigs[ index];}
>
> typedef std::vector< TextAt>::const_iterator const_iterator;
> const_iterator begin () const {return sigs.begin();}
> const_iterator end () const {return sigs.end();}
>};
>
>
>
>class TokBag : public CharBag
>{
>public:
> TokBag (const Bstring& base);
> void tokenize();
> void __attribute__((stdcall)) set (const Bstring& tokSource);
>};
>
>
>
>
>class PatList;
>
>
>class MatStar
>{
> const TokBag* toks;
> std::vector< TextPos> stars;
> int nStars;
> int baseCount;
> bool __attribute__((stdcall)) matcher (int t, int j, const PatList& pat);
> bool __attribute__((stdcall)) matching (int t, int j, const PatList& pat);
>public:
>
> MatStar ();
> void __attribute__((stdcall)) addStar (int p, int x);
> void __attribute__((stdcall)) setStar (int starIndex, int p, int x);
> void __attribute__((stdcall)) setTok (const TokBag& t);
> void __attribute__((stdcall)) setAll ();
> void __attribute__((stdcall)) setSize (int m) {nStars= m;}
> void __attribute__((stdcall)) get (int m, Bstring& dest, int sep=' ') const;
> void __attribute__((stdcall)) flat (Bstring& dest, const char* empty="") const;
> int __attribute__((stdcall)) first () const {return toks->first();}
> bool __attribute__((stdcall)) eqp (const PatList& pat) const;
> bool __attribute__((stdcall)) match (const PatList& pat);
> void __attribute__((stdcall)) show (const char* pfx= "") const;
> const TokBag& tokes () const {return *toks;}
> void hit (int x) {(static_cast<void> ((x < 100) ? 0 : (__assert_fail ("x < 100", "aiLex.h", 727, __PRETTY_FUNCTION__), 0))); if (x > 0) baseCount += x;}
> int hits () const {return baseCount;}
> bool exact () const {return stars.size() == 0;}
> size_t size () const {return stars.size();}
> void operator= (const MatStar& rhs);
> bool operator< (const MatStar& rhs) const {baseCount < rhs.baseCount;}
>};
>
>
>
>class Categoric;
>enum MatchState {IN_INPUT, IN_THAT, IN_TOPIC, numMatchStates};
>const MatchState IN_BEGIN = IN_INPUT;
>inline void operator++ (MatchState& x) {x = MatchState(x+1);}
>
>enum Grace {gvUsed= 1, gvMatch= 2, gvExact= 4, gsThat= 4, gsTopic= 8};
>inline bool isMatch (Grace g) {return g & gvMatch;}
>inline bool isExact (Grace g) {return g & gvExact;}
>bool isPerfect (Grace m);
>typedef const char* sigmaForm[ numMatchStates];
>
>class Sigma
>{
> const Categoric* winner;
> MatStar stars[ numMatchStates];
>public:
> Sigma (const Sigma& rhs);
> Sigma (const Bstring& inp, const Bstring& that, const Bstring& topic);
> Sigma (const TokBag& inp, const TokBag& that, const TokBag& topic);
> ~Sigma();
> void set (const Categoric& p);
> void set (MatchState index, const MatStar& ms);
> Grace __attribute__((stdcall)) match (MatchState ms, int probe);
> const Categoric& cat () const {return *winner;}
> const MatStar& mStar (MatchState x) const {return stars[ x];}
> MatStar& mStar (MatchState x) {return stars[ x];}
> void __attribute__((stdcall)) show (const char* pfx="") const;
> void __attribute__((stdcall)) tokes (TokList& dest) const;
> void __attribute__((stdcall)) flat (Bstring& dest ) const;
> void __attribute__((stdcall)) flat (Bstring& dest, const sigmaForm& sep) const;
> int __attribute__((stdcall)) hits () const;
>};
>
>
>
>
>
>class Sigone
>{
> const PatList& pat;
> const TokBag & toks;
> bool __attribute__((stdcall)) matcher (int t, int j, MatStar& reply) const;
> bool __attribute__((stdcall)) matching (MatStar& mat, int t, int j) const;
>
>public:
> Sigone (const PatList& p, const TokBag& b);
> bool __attribute__((stdcall)) eqp () const;
> bool __attribute__((stdcall)) match (MatStar& reply) const;
> void __attribute__((stdcall)) flat (Bstring& dest) const {toks.flat( dest);}
> void __attribute__((stdcall)) show (const char* pfx= "") const {toks.show( pfx);}
>
>
>};
>
>
>
>
>
>
>typedef union
>{
> const char *str;
> double real;
> int integer;
> int cmd;
> int node;
>} YYSTYPE;
>
>
>int __attribute__((stdcall)) pn (int a);
>int __attribute__((stdcall)) pn (int a, int b);
>int __attribute__((stdcall)) pn (int a, int b, const char* c);
>int __attribute__((stdcall)) pn (int a, const char* b);
>int __attribute__((stdcall)) pn (int a, const char* b, const char* c);
>int __attribute__((stdcall)) pn (int a, const char* b, int c);
>int __attribute__((stdcall)) pn (int a, int b, int c);
>int __attribute__((stdcall)) pv (int dotChain);
>int __attribute__((stdcall)) pnTOPIC (const char* name, int b);
>int __attribute__((stdcall)) firstCat (int cat);
>
>const char* __attribute__((stdcall)) must (const char* token, const char* keyword);
>
>
>
>
>
>class Slang
>{
>
> std::istream* ii;
> int waitCh, inTag, last;
> int Begin ();
> void endTag ();
> int get ();
> int getRaw () throw (xCept);
> void unGet (int ch);
> int grabMode (int ch);
> int grabPat (int ch);
> int grabText (int ch);
> void nonWordPattern ();
> void getNonWord (Bstring& dest);
> void getRestOfLine (Bstring& dest);
> void findBrains ();
> void glob (const char* suffix);
> void HashStop ();
> void load (const char* bfn);
> void read ();
> void eval (const Bstring& msg);
> void nextLine ();
> int nextIdent(int ch);
> void nexToke ();
> int peek ();
> void readBrains (int start);
> void rnl ();
> void scanText ();
> int ScanIdent(int, char*);
> void skipComment (int q);
> void skipSpace ();
> void startTag ();
> int yylexe ();
> int yyQuote (int);
>public:
> Slang ();
> ~Slang ();
> void close ();
> void loadBrain ();
> int lex ();
> int loadFacts ();
>};
>
>
>extern int yydebug;
>extern const char* const yytname[];
>void __attribute__((stdcall)) yxPrint (FILE* f, int tokType, YYSTYPE& val);
>int __attribute__((stdcall)) yyparse (void* ourLex);
>void __attribute__((stdcall)) yyerror (const char*);
>char inOpen ();
>char inPat ();
>char inReply ();
>char inCode ();
>char inSect ();
>char popLex ();
>int resWordCount ();
>void init_ResWords();
>const char* __attribute__((stdcall)) tokenName (int op);
>void __attribute__((stdcall)) addResWord (const char* s, short val);
>int __attribute__((stdcall)) addWord ();
>int __attribute__((stdcall)) addFact ();
>int __attribute__((stdcall)) openSect (const char* id);
>int __attribute__((stdcall)) doneSect (int head);
>int __attribute__((stdcall)) addPhrase ();
>int __attribute__((stdcall)) finishPat (int whom);
>int __attribute__((stdcall)) finishCat (int pat, int that, int reply);
>int __attribute__((stdcall)) checkBotVar (const char* ident);
>
>
>
>int uxparse ();
>void uxClose ();
>void uxDestroy ();
>void uxInit ();
>void uxReply (const UxType& reply);
>void uxOpen (Bstring& expr);
>const char* uxError (const char *s);
>extern Bstring uxResult;
>
>
>extern char* aPath;
>extern char realPath[];
>extern int debug, catLine, lineNr;
>FILE* __attribute__((stdcall)) aOpen (const char* folder, const char* file, const char* mode);
>FILE* __attribute__((stdcall)) aOpen (const char* fn, const char* mode);
>FILE* __attribute__((stdcall)) bOpen (const char* fn, const char* mode);
>void __attribute__((stdcall)) aClose (FILE* of, const char* fn, const char* whom= "");
>void __attribute__((stdcall)) setPath(const char* where);
>void __attribute__((__cdecl__)) __attribute__((noreturn)) ABEND (const char *fmt, ...) throw (xCept);
>void __attribute__((__cdecl__)) __attribute__((noreturn)) ABORT (const char *fmt, ...) throw (xCept);
>void __attribute__((__cdecl__)) __attribute__((noreturn)) LIBEL (const char *fmt, ...) throw (xCept);
>void __attribute__((__cdecl__)) WARN (const char *fmt, ...);
>void __attribute__((__cdecl__)) wo (const char *fmt, ...);
>
>
>
>inline int getClock() {return clock();}
>
>
>
>typedef std::vector< Bstring> ReplyList;
>void __attribute__((stdcall)) downCase (Bstring& dest);
>void __attribute__((stdcall)) downCase (char* dest);
>void __attribute__((stdcall)) upCase (char* dest);
>void __attribute__((stdcall)) upCase (Bstring& dest);
>void __attribute__((stdcall)) formalCase (Bstring& dest);
>void __attribute__((stdcall)) sentenceCase (Bstring& dest);
>void __attribute__((stdcall)) trim (Bstring& dest);
>void __attribute__((stdcall)) nextWord (const Bstring& s, int& pos);
>void __attribute__((stdcall)) plusSpace (Bstring& dest, int skip= 0);
>void __attribute__((stdcall)) trimWord (Bstring& dest);
>void __attribute__((stdcall)) trim (Bstring& dest);
>void __attribute__((stdcall)) trim (char* dest);
>void __attribute__((stdcall)) upCase (char* dest);
>void __attribute__((stdcall)) downCase (char* dest);
>inline void append (void** dest, const void* src, size_t n) {
> memcpy( *dest, src, n);
> *dest = (char*)(*dest) + n;
>}
>
>
>
>
>
>
>
>void __attribute__((stdcall)) unHtml (const char* buf, Bstring& dest);
>void __attribute__((stdcall)) patNdx_show (int p);
>int __attribute__((stdcall)) patNdx_line (int p);
>char* __attribute__((stdcall)) strNew (const char* s);
>char* __attribute__((stdcall)) strNew (const char* s, int n);
>inline char* strNew (const Bstring& s) {
> return strNew( s.c_str(), s.size());}
>time_t __attribute__((stdcall)) str2time (const Bstring& when, bool weekend);
>Bstring __attribute__((stdcall)) agendaTS (const time_t when);
>extern const char* humanTime;
>extern const char* diaryTime;
>
>const char* __attribute__((stdcall)) strWhen (const time_t when, const char* format);
>const char* __attribute__((stdcall)) strWhen (const char* format, int delta= 0);
>inline const char *getdts () {return strWhen("%F %T");}
>inline const char *getdate () {return strWhen("%B %d, %Y");}
>inline const char *getdow () {return strWhen("%A");}
>inline const char *gettime () {return strWhen("%I:%M %P");}
>
>
>extern int tokLen, srcLen;
>extern char tokBuf[], srcBuf[64];
>extern int sentTerm;
>extern int curBrain;
>extern int ourAgent;
>extern bool AUTHOR;
>extern Bstring userName;
>extern int options[];
>inline int& Option (int a) {return options[a-'A'];}
>
>
>extern std::vector< BrainFile *> brainList;
>extern std::vector< Bstring> saved;
>void bot_responder (Bstring& dest, const Bstring& query);
>void bot_stor (Bstring& dest, Bstring& value);
>
>
>extern Glossary glossary;
>extern FactBag facts;
>extern Affector affect;
>extern Effect pickAxe;
>extern Agenda agenda;
>extern Agenda diary;
>extern FactBag client;
>extern Nouns properNoun;
>extern Nouns units;
>extern Roler person;
>extern Roler person2;
>extern Roler personf;
>extern Roler gender;
>extern Roler speller;
>extern Roler dateTime;
>extern Roler deGossip;
>extern void initRolers ();
>extern const Bstring empty;
>extern const CiteList citeListEmpty;
>extern Loadable* curSection;
>extern Bstring userInput, userTidy;
>extern Bstring botsMessage;
>typedef std::map< Bstring, int> WordNumber;
>extern WordNumber patWords;
>extern WordNumber factWords;
>void showVocabulary (const WordNumber& voc, const char* whom, const Bstring& comment);
>extern Bstring curSubj;
>extern History< Cite> things;
>template <typename T>
>void __attribute__((stdcall)) dump (const History< T>& h);
>void pushThings (const Bstring& s);
>template <typename Container>
>void __attribute__((stdcall)) stringTok (Container &dest, const Bstring& in);
>
>
>
>void __attribute__((stdcall)) padRoler (Bstring& dest, const char* text, const char* pre=""
> , const char* post="");
>void __attribute__((stdcall)) whatIsTheSubject (Bstring& dest, Bstring& msg);
>void __attribute__((stdcall)) moodFeel (Bstring& dest);
>void __attribute__((stdcall)) moodFlat (Bstring& dest);
>Bstring __attribute__((stdcall)) moodSense (const Bstring& augment);
>void __attribute__((stdcall)) moodShow (Bstring& dest);
>bool __attribute__((stdcall)) doMeans (Bstring& msg);
>void __attribute__((stdcall)) findRelevant ();
>void __attribute__((stdcall)) showRelevant ();
>void __attribute__((stdcall)) replyRelevant (Bstring& reply, Bstring& query);
>void __attribute__((stdcall)) getAffect (Bstring& msg);
>void __attribute__((stdcall)) doFetch (Bstring& dest, Bstring& subject);
>
>
>const char* __attribute__((stdcall)) morphy (const char *origstr);
># 5 "apFact.cpp" 2
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 1 3
># 47 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 3
> 
># 48 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 3
>
>
>
>
># 1 "/usr/include/math.h" 1 3 4
># 29 "/usr/include/math.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 34 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 36 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 37 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 40 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 43 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 36 "/usr/include/bits/mathdef.h" 3 4
>typedef long double float_t;
>
>typedef long double double_t;
># 47 "/usr/include/math.h" 2 3 4
># 70 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
>
>extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
>
>extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
>
>extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
>
>
>extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
>
>extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
>
>extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
>
>
>
>
>extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
>
>extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
>
>extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
>
>
>
>
>
>
>extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
>
>extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
>
>extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
>
>
>
>
>
>
>
>extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
>
>
>extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
>
>
>extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
>
>
>extern double log (double __x) throw (); extern double __log (double __x) throw ();
>
>
>extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
>
>
>extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();
>
>
>
>
>extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
>
>extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
>
>
>
>
>
>extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
>
>
>extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
>
>
>extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
>
>
>
>
>
>
>extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
>
>
>extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
>
>
>extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
>
>
>
>
>
>extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
>
>
>
>
>
>
>extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
>
>
>extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
>
>
>
>
>extern int __isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finite (double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
>
>
>
>extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
>
>
>
>
>
>extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) throw () __attribute__ ((__const__));
>
>
>extern double j0 (double) throw (); extern double __j0 (double) throw ();
>extern double j1 (double) throw (); extern double __j1 (double) throw ();
>extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
>extern double y0 (double) throw (); extern double __y0 (double) throw ();
>extern double y1 (double) throw (); extern double __y1 (double) throw ();
>extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
>
>
>
>
>
>
>extern double erf (double) throw (); extern double __erf (double) throw ();
>extern double erfc (double) throw (); extern double __erfc (double) throw ();
>extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
>
>
>
>
>
>
>extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
>
>
>
>
>
>extern double gamma (double) throw (); extern double __gamma (double) throw ();
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
>
>
>extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
>
>
>
>extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
>
>
>
>extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
>
>
>
>
>extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
>
>
>
>extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
>
>
>
>extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
>extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
>
>
>
>extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
>extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
>
>
>
>extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
>
>
>extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();
>
>
>extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();
>
>
>
>extern int __fpclassify (double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
>
>
>
>
>extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
># 71 "/usr/include/math.h" 2 3 4
># 93 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
>
>extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
>
>extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
>
>extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
>
>
>extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
>
>extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
>
>extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
>
>
>
>
>extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
>
>extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
>
>extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
>
>
>
>
>extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
>
>
>
>
>
>
>extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
>
>extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
>
>extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
>
>
>
>
>
>
>
>extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
>
>
>extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
>
>
>extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
>
>
>extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
>
>
>extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
>
>
>extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();
>
>
>
>
>extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
>
>extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
>
>
>
>
>
>extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
>
>
>extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
>
>
>extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
>
>
>
>
>
>
>extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
>
>
>extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
>
>
>extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
>
>
>
>
>
>extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
>
>
>
>
>
>
>extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
>
>
>
>
>extern int __isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
>
>
>
>extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
>
>
>
>
>
>extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>extern float j0f (float) throw (); extern float __j0f (float) throw ();
>extern float j1f (float) throw (); extern float __j1f (float) throw ();
>extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
>extern float y0f (float) throw (); extern float __y0f (float) throw ();
>extern float y1f (float) throw (); extern float __y1f (float) throw ();
>extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
>
>
>
>
>
>
>extern float erff (float) throw (); extern float __erff (float) throw ();
>extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
>extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
>
>
>
>
>
>
>extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
>
>
>
>
>
>extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
>
>
>extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
>
>
>
>extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
>
>
>
>extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
>
>
>
>
>extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
>
>
>
>extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
>
>
>
>extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
>extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
>
>
>
>extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
>extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
>
>
>
>extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
>
>
>extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();
>
>
>extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();
>
>
>
>extern int __fpclassifyf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
>
>
>
>
>extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
># 94 "/usr/include/math.h" 2 3 4
># 114 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
>
>extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
>
>extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
>
>extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
>
>
>extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
>
>extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
>
>extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
>
>
>
>
>extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
>
>extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
>
>extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
>
>
>
>
>extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
>
>
>
>
>
>
>extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
>
>extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
>
>extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
>
>
>
>
>
>
>
>extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
>
>
>extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
>
>
>extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
>
>
>extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
>
>
>extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
>
>
>extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();
>
>
>
>
>extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
>
>extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
>
>
>
>
>
>extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
>
>
>extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
>
>
>extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
>
>
>
>
>
>
>extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
>
>
>extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
>
>
>extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
>
>
>
>
>
>
>extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
>
>
>
>
>extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
>
>
>
>extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
>extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
>extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
>extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
>extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
>extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
>
>
>
>
>
>
>extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
>extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
>extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
>
>
>
>
>
>
>extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
>
>
>
>
>
>extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
>
>
>extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
>
>
>
>extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
>
>
>
>extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
>
>
>
>extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
>
>
>
>extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
>extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
>
>
>
>extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
>extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
>
>
>
>extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
>
>
>extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();
>
>
>extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();
>
>
>
>extern int __fpclassifyl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
>
>
>
>
>extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
># 115 "/usr/include/math.h" 2 3 4
># 130 "/usr/include/math.h" 3 4
>extern int signgam;
># 171 "/usr/include/math.h" 3 4
>enum
> {
> FP_NAN,
>
> FP_INFINITE,
>
> FP_ZERO,
>
> FP_SUBNORMAL,
>
> FP_NORMAL
>
> };
># 257 "/usr/include/math.h" 3 4
>typedef enum
>{
> _IEEE_ = -1,
> _SVID_,
> _XOPEN_,
> _POSIX_,
> _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 280 "/usr/include/math.h" 3 4
>struct __exception
>
>
>
> {
> int type;
> char *name;
> double arg1;
> double arg2;
> double retval;
> };
>
>
>extern int matherr (struct __exception *__exc) throw ();
># 438 "/usr/include/math.h" 3 4
>}
># 53 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 2 3
># 81 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 3
>namespace std
>{
>
>
> template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
>
> inline double
> abs(double __x)
> { return __builtin_fabs(__x); }
>
> inline float
> abs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline long double
> abs(long double __x)
> { return __builtin_fabsl(__x); }
>
> using ::acos;
>
> inline float
> acos(float __x)
> { return __builtin_acosf(__x); }
>
> inline long double
> acos(long double __x)
> { return __builtin_acosl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> acos(_Tp __x)
> {
> return __builtin_acos(__x);
> }
>
> using ::asin;
>
> inline float
> asin(float __x)
> { return __builtin_asinf(__x); }
>
> inline long double
> asin(long double __x)
> { return __builtin_asinl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> asin(_Tp __x)
> { return __builtin_asin(__x); }
>
> using ::atan;
>
> inline float
> atan(float __x)
> { return __builtin_atanf(__x); }
>
> inline long double
> atan(long double __x)
> { return __builtin_atanl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> atan(_Tp __x)
> { return __builtin_atan(__x); }
>
> using ::atan2;
>
> inline float
> atan2(float __y, float __x)
> { return __builtin_atan2f(__y, __x); }
>
> inline long double
> atan2(long double __y, long double __x)
> { return __builtin_atan2l(__y, __x); }
>
> template<typename _Tp, typename _Up>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type
> && __is_integer<_Up>::_M_type>::_M_type
> atan2(_Tp __y, _Up __x)
> { return __builtin_atan2(__y, __x); }
>
> using ::ceil;
>
> inline float
> ceil(float __x)
> { return __builtin_ceilf(__x); }
>
> inline long double
> ceil(long double __x)
> { return __builtin_ceill(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> ceil(_Tp __x)
> { return __builtin_ceil(__x); }
>
> using ::cos;
>
> inline float
> cos(float __x)
> { return __builtin_cosf(__x); }
>
> inline long double
> cos(long double __x)
> { return __builtin_cosl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> cos(_Tp __x)
> { return __builtin_cos(__x); }
>
> using ::cosh;
>
> inline float
> cosh(float __x)
> { return __builtin_coshf(__x); }
>
> inline long double
> cosh(long double __x)
> { return __builtin_coshl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> cosh(_Tp __x)
> { return __builtin_cosh(__x); }
>
> using ::exp;
>
> inline float
> exp(float __x)
> { return __builtin_expf(__x); }
>
> inline long double
> exp(long double __x)
> { return __builtin_expl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> exp(_Tp __x)
> { return __builtin_exp(__x); }
>
> using ::fabs;
>
> inline float
> fabs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline long double
> fabs(long double __x)
> { return __builtin_fabsl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> fabs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::floor;
>
> inline float
> floor(float __x)
> { return __builtin_floorf(__x); }
>
> inline long double
> floor(long double __x)
> { return __builtin_floorl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> floor(_Tp __x)
> { return __builtin_floor(__x); }
>
> using ::fmod;
>
> inline float
> fmod(float __x, float __y)
> { return __builtin_fmodf(__x, __y); }
>
> inline long double
> fmod(long double __x, long double __y)
> { return __builtin_fmodl(__x, __y); }
>
> using ::frexp;
>
> inline float
> frexp(float __x, int* __exp)
> { return __builtin_frexpf(__x, __exp); }
>
> inline long double
> frexp(long double __x, int* __exp)
> { return __builtin_frexpl(__x, __exp); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> frexp(_Tp __x, int* __exp)
> { return __builtin_frexp(__x, __exp); }
>
> using ::ldexp;
>
> inline float
> ldexp(float __x, int __exp)
> { return __builtin_ldexpf(__x, __exp); }
>
> inline long double
> ldexp(long double __x, int __exp)
> { return __builtin_ldexpl(__x, __exp); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> ldexp(_Tp __x, int __exp)
> { return __builtin_ldexp(__x, __exp); }
>
> using ::log;
>
> inline float
> log(float __x)
> { return __builtin_logf(__x); }
>
> inline long double
> log(long double __x)
> { return __builtin_logl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> log(_Tp __x)
> { return __builtin_log(__x); }
>
> using ::log10;
>
> inline float
> log10(float __x)
> { return __builtin_log10f(__x); }
>
> inline long double
> log10(long double __x)
> { return __builtin_log10l(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> log10(_Tp __x)
> { return __builtin_log10(__x); }
>
> using ::modf;
>
> inline float
> modf(float __x, float* __iptr)
> { return __builtin_modff(__x, __iptr); }
>
> inline long double
> modf(long double __x, long double* __iptr)
> { return __builtin_modfl(__x, __iptr); }
>
> template<typename _Tp>
> inline _Tp
> __pow_helper(_Tp __x, int __n)
> {
> return __n < 0
> ? _Tp(1)/__cmath_power(__x, -__n)
> : __cmath_power(__x, __n);
> }
>
> using ::pow;
>
> inline float
> pow(float __x, float __y)
> { return __builtin_powf(__x, __y); }
>
> inline long double
> pow(long double __x, long double __y)
> { return __builtin_powl(__x, __y); }
>
> inline double
> pow(double __x, int __i)
> { return __pow_helper(__x, __i); }
>
> inline float
> pow(float __x, int __n)
> { return __pow_helper(__x, __n); }
>
> inline long double
> pow(long double __x, int __n)
> { return __pow_helper(__x, __n); }
>
> using ::sin;
>
> inline float
> sin(float __x)
> { return __builtin_sinf(__x); }
>
> inline long double
> sin(long double __x)
> { return __builtin_sinl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> sin(_Tp __x)
> { return __builtin_sin(__x); }
>
> using ::sinh;
>
> inline float
> sinh(float __x)
> { return __builtin_sinhf(__x); }
>
> inline long double
> sinh(long double __x)
> { return __builtin_sinhl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> sinh(_Tp __x)
> { return __builtin_sinh(__x); }
>
> using ::sqrt;
>
> inline float
> sqrt(float __x)
> { return __builtin_sqrtf(__x); }
>
> inline long double
> sqrt(long double __x)
> { return __builtin_sqrtl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> sqrt(_Tp __x)
> { return __builtin_sqrt(__x); }
>
> using ::tan;
>
> inline float
> tan(float __x)
> { return __builtin_tanf(__x); }
>
> inline long double
> tan(long double __x)
> { return __builtin_tanl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> tan(_Tp __x)
> { return __builtin_tan(__x); }
>
> using ::tanh;
>
> inline float
> tanh(float __x)
> { return __builtin_tanhf(__x); }
>
> inline long double
> tanh(long double __x)
> { return __builtin_tanhl(__x); }
>
> template<typename _Tp>
> inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
> tanh(_Tp __x)
> { return __builtin_tanh(__x); }
>}
>
>
>
>
>
>
>namespace __gnu_cxx
>{
> template<typename _Tp>
> int
> __capture_fpclassify(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __fpclassifyf (__f) : sizeof (__f) == sizeof (double) ? __fpclassify (__f) : __fpclassifyl (__f)); }
>
> template<typename _Tp>
> int
> __capture_isfinite(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __finitef (__f) : sizeof (__f) == sizeof (double) ? __finite (__f) : __finitel (__f)); }
>
> template<typename _Tp>
> int
> __capture_isinf(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __isinff (__f) : sizeof (__f) == sizeof (double) ? __isinf (__f) : __isinfl (__f)); }
>
> template<typename _Tp>
> int
> __capture_isnan(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __isnanf (__f) : sizeof (__f) == sizeof (double) ? __isnan (__f) : __isnanl (__f)); }
>
> template<typename _Tp>
> int
> __capture_isnormal(_Tp __f) { return ((sizeof (__f) == sizeof (float) ? __fpclassifyf (__f) : sizeof (__f) == sizeof (double) ? __fpclassify (__f) : __fpclassifyl (__f)) == FP_NORMAL); }
>
> template<typename _Tp>
> int
> __capture_signbit(_Tp __f) { return (sizeof (__f) == sizeof (float) ? __signbitf (__f) : sizeof (__f) == sizeof (double) ? __signbit (__f) : __signbitl (__f)); }
>
> template<typename _Tp>
> int
> __capture_isgreater(_Tp __f1, _Tp __f2)
> { return __builtin_isgreater(__f1, __f2); }
>
> template<typename _Tp>
> int
> __capture_isgreaterequal(_Tp __f1, _Tp __f2)
> { return __builtin_isgreaterequal(__f1, __f2); }
>
> template<typename _Tp>
> int
> __capture_isless(_Tp __f1, _Tp __f2) { return __builtin_isless(__f1, __f2); }
>
> template<typename _Tp>
> int
> __capture_islessequal(_Tp __f1, _Tp __f2)
> { return __builtin_islessequal(__f1, __f2); }
>
> template<typename _Tp>
> int
> __capture_islessgreater(_Tp __f1, _Tp __f2)
> { return __builtin_islessgreater(__f1, __f2); }
>
> template<typename _Tp>
> int
> __capture_isunordered(_Tp __f1, _Tp __f2)
> { return __builtin_isunordered(__f1, __f2); }
>}
># 518 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 3
>namespace __gnu_cxx
>{
> template<typename _Tp>
> int
> fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
>
> template<typename _Tp>
> int
> isfinite(_Tp __f) { return __capture_isfinite(__f); }
>
> template<typename _Tp>
> int
> isinf(_Tp __f) { return __capture_isinf(__f); }
>
> template<typename _Tp>
> int
> isnan(_Tp __f) { return __capture_isnan(__f); }
>
> template<typename _Tp>
> int
> isnormal(_Tp __f) { return __capture_isnormal(__f); }
>
> template<typename _Tp>
> int
> signbit(_Tp __f) { return __capture_signbit(__f); }
>
> template<typename _Tp>
> int
> isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
>
> template<typename _Tp>
> int
> isgreaterequal(_Tp __f1, _Tp __f2)
> { return __capture_isgreaterequal(__f1, __f2); }
>
> template<typename _Tp>
> int
> isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
>
> template<typename _Tp>
> int
> islessequal(_Tp __f1, _Tp __f2)
> { return __capture_islessequal(__f1, __f2); }
>
> template<typename _Tp>
> int
> islessgreater(_Tp __f1, _Tp __f2)
> { return __capture_islessgreater(__f1, __f2); }
>
> template<typename _Tp>
> int
> isunordered(_Tp __f1, _Tp __f2)
> { return __capture_isunordered(__f1, __f2); }
>}
>
>namespace std
>{
> using __gnu_cxx::fpclassify;
> using __gnu_cxx::isfinite;
> using __gnu_cxx::isinf;
> using __gnu_cxx::isnan;
> using __gnu_cxx::isnormal;
> using __gnu_cxx::signbit;
> using __gnu_cxx::isgreater;
> using __gnu_cxx::isgreaterequal;
> using __gnu_cxx::isless;
> using __gnu_cxx::islessequal;
> using __gnu_cxx::islessgreater;
> using __gnu_cxx::isunordered;
>}
>
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/cmath.tcc" 1 3
># 35 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/bits/cmath.tcc" 3
>namespace std
>{
> template<typename _Tp>
> inline _Tp
> __cmath_power(_Tp __x, unsigned int __n)
> {
> _Tp __y = __n % 2 ? __x : 1;
>
> while (__n >>= 1)
> {
> __x = __x * __x;
> if (__n % 2)
> __y = __y * __x;
> }
>
> return __y;
> }
>}
># 593 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/cmath" 2 3
># 6 "apFact.cpp" 2
>using namespace std;
>
>
>const int Past= -1, Present= 0, Future= 1;
>void AddQuestionMark (Bstring& dest);
>
>
>void changeToSubject (Bstring& dest);
>void changeYourForMyEtc (Bstring& dest);
>bool checkForThings (Bstring& dest, const Bstring& msg);
>void correctAWithAn (Bstring& dest);
>void correctGrammarEtc (Bstring& dest);
>time_t DateAdd(const char*, int augment, const time_t& Date);
>int DateDiff (const char*, time_t UserActivity, time_t BotActivity);
>inline void DoEvents () {}
>void extractRelevantText (Bstring& dest, const Bstring& from);
>void findRelevantFacts ();
>void findRemarkable ();
>void findPersonal (Bstring& reply);
>void getAlternativesAndVariables ();
>void getSubject (const Bstring& s);
>bool setVariable (const Bstring& msg);
>void obtainRelevantSet (const Signature& need);
>
>
>const Bstring empty;
>const Signature emptySign;
>Glossary glossary;
>FactBag facts("facts");
>FactBag jokes("jokes");
>FactBag trivia("trivia");
>FactBag smalltalk("smalltalk");
>FactBag client("client", "personal facts");
>Agenda agenda("agenda", "your calendar");
>Agenda diary("diary" , "previous events");
>Affector affect("affect");
>Effect pickAxe("msagent");
>Effect pickHap("haptek" );
>Roler wordMath("wordMath");
>Nouns properNoun("proper");
>
>History< Cite> things( 20, "things");
>Bstring curSubj;
>
>Bstring botsMessage;
>Bstring outMessage;
>Bstring PrevioususerInput, LastInMessage;
>Bstring newSubject;
>Bstring twixMsg;
>Bstring Subject;
>Bstring BareSubject;
>Bstring Statement;
>Bstring userName;
>
>int Debug= 1;
>int RamblePause;
>int RamblingAllowed = 1;
>int MultiAnswerMode= 0;
># 81 "apFact.cpp"
>const char white[] = " \t\n\r\f\v";
>
>
>
>
>
>
>
>const char trivialWords[] = "what . , ; -- which who why "
> "a about all am among an and any are as at be become been before but by "
> "can call calling come coming could did do does each every "
> "few for from get got gotten had has have how "
> "if in into is it just know known like "
> "may maybe might more most much must no none not of on once one only or "
> "rather really "
> "say several shall should some something soon sooner subject such "
> "tell that the then their there this thrice through thru thorough "
> "to too true truly twice very "
> "was well were will with wont won't would yes x";
>int citeTrivial= -1;
>
>
>
>
>Phrase::Phrase ()
> : w(0)
> , ourFacts(), frequency(0)
> , ourGang( 0)
> {}
>
>
>
>Phrase::Phrase (const Phrase& p)
> : self( p.self), w( p.w), len( p.len)
> , proper( p.proper)
>{
> frequency = p.frequency;
> ourGang = p.ourGang;
> ourFacts = p.ourFacts;
>}
>void Phrase::operator= (const Phrase& p) {
> self = p.self;
> w = p.w;
> len = -p.len;
> proper = p.proper;
> frequency = p.frequency;
> ourGang = p.ourGang;
> ourFacts = p.ourFacts;
>}
>
>
>
>Phrase::~Phrase ()
> {}
>Glossary::Glossary () : Loadable("glossary"), data(), dict()
> {}
>
>
>Glossary::~Glossary () {
> for (int j= 1; j < data.size(); ++j) {
> delete[] data[j].s();
> }
>}
>
>Loadable::Loadable (const char* who, const char* what)
> : me( who)
> , comment( what)
> , dirty(false)
> , section( -1)
> {}
>Loadable::~Loadable ()
> {}
>void Loadable::done () {
> dirty= false;
>}
>void Loadable::write (FILE*) {
> if (! dirty || empty()) return;
> ABEND("Loadable [%s %s] dirty but not writable",me, comment.c_str());
>}
>
>Provenance::Provenance (int b, int ord, Loadable* us)
> : brain( b), ordinal( ord), who( us), priority( us->priority)
> {}
>
>
>Agenda::Agenda (const char* who, const char* what)
> : Loadable( who, what), data()
> {}
>Agenda::~Agenda ()
> {}
>
>void Agenda::add (const Bstring& s) {
> dirty = true;
> data.push_back( s);
>}
>void Agenda::write (FILE* sv) {
> if (empty()) return;
> fprintf(sv, "\n[%s %s]\n", me, comment.c_str());
> Agenda::const_iterator v = begin();
> while (v != end()) {
> fprintf( sv, "%s\n", v->c_str());
> ++v;
> }
> dirty= false;
>}
>
>void Agenda::pare (Agenda& newer, const time_t mark) {
> if (newer.empty()) return;
> const Bstring expiry = agendaTS( mark);
> vector< Bstring>::iterator v = newer.data.begin();
> while (v != newer.end()) {
>
> if (*v <= expiry) {
>
> add( *v);
> v = newer.data.erase( v);
> dirty= true;
> }else{
> ++v;
> }
> }
>}
>static const char* clientHeader =
> "\n#* the system remembers these facts for you, personally.\n"
> "[%s %s]\n";
>
>void FactBag::write (FILE* sv) {
> if (empty()) return;
> fprintf(sv, "\n[%s %s]\n", me, comment.c_str());
> const vector< Bstring>::const_iterator end = gloss.end();
> vector< Bstring>::const_iterator v = gloss.begin();
> while (v != end) {
> fprintf( sv, "%s\n", v->c_str());
> ++v;
> }
> dirty= false;
>}
>
>
>
>
>
>
>Cite Glossary::lookup (const char* w) {
> Cite x = find( w);
> if (x < 0) {
> x = addWord( w);
> }
> Phrase& p( data[ x]);
> ++ p.frequency;
> return x;
>}
>
>
>
>Cite Glossary::addWord (const char* s) {
> Cite x = data.size();
> Phrase z;
> data.push_back( z);
> Phrase& p( data.back());
> (static_cast<void> ((x == data.size() - 1) ? 0 : (__assert_fail ("x == data.size() - 1", "apFact.cpp", 241, __PRETTY_FUNCTION__), 0)));
> p.self = x;
> p.len = strlen( s);
> p.w = strNew( s, p.len);
> Bstring word( s);
> dict[ word] = x;
> if (Option('V') > 3 || (
> Option('V') && p.len >= 2 && isupper( p.w[0]) && isupper( p.w[1]))) {
> wo("GlossAdd %-6d {%s}\n", x, p.w);
> }
> return x;
>}
>
>
>
>Cite Glossary::find (const char* w) const {
># 265 "apFact.cpp"
> Bstring b( w);
> map< Bstring, int, IgCaseLess>::const_iterator hit = dict.find( b);
> if (hit != dict.end()) {
> return hit->second;
> }
>
> return citeNone;
>}
>
>
>
>
>
>void Glossary::init () {
> (static_cast<void> ((data.size() == 0) ? 0 : (__assert_fail ("data.size() == 0", "apFact.cpp", 279, __PRETTY_FUNCTION__), 0)));
> data.reserve( 1024);
> Cite z = addWord("");
>
> (static_cast<void> ((data.size() == 1) ? 0 : (__assert_fail ("data.size() == 1", "apFact.cpp", 283, __PRETTY_FUNCTION__), 0)));
> addWord("what");
> (static_cast<void> ((lookup("what") == citeWhat) ? 0 : (__assert_fail ("lookup(\"what\") == citeWhat", "apFact.cpp", 285, __PRETTY_FUNCTION__), 0)));
> (static_cast<void> ((citeTrivial == -1) ? 0 : (__assert_fail ("citeTrivial == -1", "apFact.cpp", 286, __PRETTY_FUNCTION__), 0)));
> CiteList dummy( trivialWords);
> citeTrivial = data.size();
> facts.init();
> jokes.init();
> trivia.init();
> client.init();
> uxInit();
>}
>
>void Glossary::add (const Bstring& line) {
> Bstring head( line);
> if (head[0] == '=') {
> head.erase(0, 1);
> addAll( head);
> return;
> }
> Bstring tail;
> head.split( tail);
> head.replaceUnder();
>
> const Cite lhs( lookup( head));
> Phrase& p( data[ lhs]);
> Signature* assoc = p.ourGang;
> if (assoc) {
>
>
> assoc = new Signature( *assoc);
> }else{
> assoc= new Signature();
> p.ourGang = assoc;
> }
> assoc->add( lhs);
> if (! tail.empty()) {
>
>
>
>
>
> CiteList more( tail);
> assoc->add( more);
> }
> if (Option('S') > 1 && 1600 <= lhs && lhs < 1700) {
> wo(" gah %d{%s}{%s}\n", lhs, tail.c_str(), assoc->toStr().c_str());
> }
>}
>
>void Glossary::addAll (const Bstring& line) {
> Signature* assoc( new Signature( line));
> Signature::const_iterator a = assoc->begin();
>
> while (a != assoc->end()) {
> if (data[ *a].ourGang) {
> data[ *a].ourGang->add( *assoc);
> }else{
> data[ *a].ourGang = assoc;
> }
>
> ++a;
> }
>
>}
>const Signature& Glossary::gang (const Cite index) const {
> const Signature* assoc = data[ index].ourGang;
> return assoc? *assoc : &emptySign;
>}
># 361 "apFact.cpp"
>CiteList::CiteList (const Bstring& inp) {
> Bstring msg( inp);
> speller.dsub( msg);
> msg.replace("--", " -- ");
> static const char* delimiters = " \t\n\r\f\v,;()!?\"";
> const bool keepNoise = false;
> const size_t len = msg.size();
> size_t j = 0;
> while (j < len) {
> j = msg.find_first_not_of( delimiters, j);
> if (j == string::npos) break;
> size_t k = msg.find_first_of( delimiters, j);
> if (k == string::npos) {
> k = len;
> }
> Bstring next( msg.substr( j, k-j));
> next.replaceUnder();
>
> while (! next.empty() && (next.last() == '.' || next.last() == ' '))
> next.erase( next.size()-1);
> if (! next.empty() && next != ".") {
> Cite w = glossary.lookup( next);
> if (keepNoise || w >= citeTrivial)
> add( w);
> }
> j = k + 1;
> }
> multi();
>}
>
>
>void CiteList::multi () {
> int j= 0;
> int d= 0;
> while (j < size()) {
> Bstring m( glossary.get( alts[ j]));
> int k= j+1;
> size_t goodLength= 0;
> while (k < size()) {
> m << ' ' << glossary.get( alts[ k]);
> if (glossary.find( m) == citeNone) break;
> goodLength= m.size();
> ++k;
> }
> if (k > j+1) {
> (static_cast<void> ((goodLength > 0) ? 0 : (__assert_fail ("goodLength > 0", "apFact.cpp", 406, __PRETTY_FUNCTION__), 0)));
> m.erase( goodLength);
> Cite phrase= glossary.lookup( m);
> alts[ d] = phrase;
>
> j = k;
> alts[ d++] = phrase;
> }else{
> alts[ d++] = alts[ j++];
> }
> }
> (static_cast<void> ((j == alts.size()) ? 0 : (__assert_fail ("j == alts.size()", "apFact.cpp", 417, __PRETTY_FUNCTION__), 0)));
> if (d < j) alts.resize( d);
>}
>
>
>void CiteList::add (const CiteList& f) {
> const_iterator j = f.begin();
> while (j != f.end()) {
> alts.push_back( *j);
> ++j;
> }
> if (alts.size() > 50) {
> wo(" big! %d {%s}\n", alts.size(), toStr().c_str());
> }
>}
># 443 "apFact.cpp"
>void CiteList::show () const {
> wo("%d{%s}\n", size(), toStr().c_str());
>}
>
>
>
>Bstring CiteList::toStr (int start, const Bstring& sep) const {
> Bstring dest;
> const_iterator a = alts.begin();
> while (start > 0) {
> ++a;
> --start;
> }
> while (a != alts.end()) {
> dest << glossary.get(*a) << sep;
> ++a;
> }
> if (dest.size() > 1)
> dest.erase( dest.size()-1);
> return dest;
>}
>
>
>Signature::Signature (const Bstring& s) : guts() {
> CiteList f( s);
> add( f);
>}
>Signature::Signature (const Signature& more) : guts() {
> add( more);
>}
>
>
>
>
>bool Signature::match (const Signature& more) const {
> const_iterator x = more.begin();
> while (x != more.end()) {
> if (has( *x)) return true;
> ++x;
> }
> return false;
>}
>
>Signature Signature::operator * (const Signature& rhs) const {
> Signature reply;
> set_intersection( guts.begin(), guts.end(), rhs.guts.begin(), rhs.guts.end()
> , insert_iterator< SigSet>( reply.guts, reply.guts.begin()) );
> return reply;
>}
># 515 "apFact.cpp"
>void Signature::add (const Signature& source) {
> const_iterator x = source.begin();
> while (x != source.end()) {
> if (*x >= citeTrivial) add( *x);
> ++x;
> }
>}
>
>void Signature::add (const CiteList& source) {
> CiteList::const_iterator x = source.begin();
> while (x != source.end()) {
> if (*x >= citeTrivial) add( *x);
> ++x;
> }
>}
>
>
>
>
>
>
>const char* morphy (const char* arg) {return arg;}
>
>void Signature::add (Cite c) {
> if (c < citeTrivial) return;
> const char* w( glossary.get( c));
> const char* arg( w);
> do {
> const char* m = morphy( arg);
> if (! m) break;
> c = glossary.lookup( m);
> if (c >= citeTrivial) {
> if (Option('S') > 5 || m == "me")
> wo("sg+ %-5d {%s}\n", c, glossary.get( c));
> guts.insert( c);
> }
> arg= 0;
> }while(1);
>}
>
>Bstring Signature::toStr () const {
> Bstring dest;
> const_iterator a = begin();
> while (a != end()) {
> dest += glossary.get(*a);
> dest += ", ";
> ++a;
> }
> if (dest.size() > 1)
> dest.erase( dest.size()-2);
> return dest;
>}
>
>
>map< Bstring, Loadable*> roles;
>vector< Provenance> sections;
>int curFrom= 0;
>Loadable* curSection = 0;
>Bstring curFact;
>size_t curSectionPrevSize= 0;
>
>
>
>class SkipLoad : public Loadable
>{
>public:
> SkipLoad (const char* me) : Loadable( me) {}
> void add (const Bstring& f) {}
> void add (const Bstring& f, const Bstring& g) {}
> void done () {}
> bool empty () const {return true;}
> size_t size () const {return 0;}
>};
>
>SkipLoad skipper("skipper");
>
>
>
>
>int openSect (const char* id) {
> const char * curHead = 0;
> if (curSection)
> doneSect( 0);
> (static_cast<void> ((curSection == 0) ? 0 : (__assert_fail ("curSection == 0", "apFact.cpp", 598, __PRETTY_FUNCTION__), 0)));
> curHead = id;
> map< Bstring, Loadable*>::iterator x = roles.find( curHead);
> if (x == roles.end()) {
># 610 "apFact.cpp"
> ABEND("unknown %d section {%s}", roles.size(), curHead);
> curSection = &skipper;
> }else{
> curSection = x->second;
> }
> curFrom = curSection->open();
> return curSectionPrevSize= curSection->size();
>}
>int Loadable::open () {
> section = sections.size();
> curFact >> priority;
> if (priority < 0 || priority > 15) priority= 16;
> comment = curFact;
>
> sections.push_back( Provenance( curBrain, section, this));
> if (Option('V')) {
>
> wo("---- open Sect %d/%-2d [%s %s]\n"
> , curFrom, curBrain, me, curFact.c_str());
> }
> curFact.clear();
> return section;
>}
>int doneSect (int head) {
> curSection->done();
> if (Option('V')) {
> wo("---- done Sect %d/%-2d %4d %s\n", curFrom, curBrain
> , curSection->size() - curSectionPrevSize, curSection->me);
> }
> if (! curFact.empty()) {
> WARN("%s.done() dangling facts %d", curSection->me, curFact.size());
> }
> curFact.clear();
> curSection = 0;
> return head;
>}
>
>
>
>int addFact () {
> curFact.trim();
> curSection->add( curFact);
> if (Option('P') && Option('V') > 5)
> wo("af %-5d {%s}\n", curSection->size(), curFact.c_str());
> curFact.clear();
> return curSection->size();
>}
>
>
>
>int addWord () {
> if (strlen( tokBuf) != tokLen) {
> ABEND(" addWord at %d %d<>%d {%s}\n"
> , lineNr, tokLen, strlen(tokBuf), tokBuf);
> }
>
>
>
>
>
>
> curFact += tokBuf;
> curFact += ' ';
>
> return curFact.size();
>}
>
>FactBag::FactBag (const char* who, const char* what)
> : Loadable( who, what), gloss(), meat(), from()
> , lastBeat(), factDial(0)
> {}
>FactBag::~FactBag () {}
>
>
>void FactBag::add (const Bstring& s) {
>
> const int thisFact = size();
> gloss .push_back( s);
> from .push_back( curFrom);
> priority.push_back( sections[ curFrom].priority);
> lastBeat.push_back( 0);
> Signature g( s);
> meat.push_back( g);
>
> const Signature::const_iterator last = g.end();
> Signature::const_iterator x = g.begin();
> while (x != last) {
> glossary.refBy( *x, thisFact);
> ++x;
> }
>}
>
>void FactBag::init () {
> gloss .reserve( 1024);
> meat .reserve( 1024);
> from .reserve( 1024);
> priority.reserve( 1024);
> lastBeat.reserve( 1024);
> (static_cast<void> ((gloss.size() == 0) ? 0 : (__assert_fail ("gloss.size() == 0", "apFact.cpp", 708, __PRETTY_FUNCTION__), 0)));
> const Signature signatureNone;
> gloss.push_back("");
> meat .push_back(signatureNone);
> from .push_back(0);
> lastBeat.push_back(0);
> priority.push_back(0);
> (static_cast<void> ((size() == 1) ? 0 : (__assert_fail ("size() == 1", "apFact.cpp", 715, __PRETTY_FUNCTION__), 0)));
>}
>
>void FactBag::compile () {
> if (Option('K') & 2) {
> WordFreq factWords;
> facts .frequency( factWords);
> jokes .frequency( factWords);
> trivia.frequency( factWords);
> smalltalk.frequency( factWords);
> showVocabulary( factWords, "facts", "words in facts, jokes, and trivia");
> }
># 737 "apFact.cpp"
> getAlternativesAndVariables();
> facts.resetScan();
>}
>
>
>void FactBag::frequency (WordFreq& wf) const {
> for (int n= 1; n < size(); ++n) {
> CiteList f( get( n));
> const CiteList::const_iterator end = f.end();
> CiteList::const_iterator x = f.begin();
> while (x != end) {
> Bstring spell( glossary.get( *x));
> ++wf[ spell];
> ++x;
> }
> }
>}
>
>
>void Nouns::add (const Bstring& noun) {
> Bstring kind;
> Bstring key( noun);
> key.split( kind);
> key.replaceUnder();
> data[ key] = kind;
>}
>void Nouns::add (const Bstring& var, const Bstring& valu) {
> Bstring work( var);
> work.replaceUnder();
> data[ work] = valu;
>}
>
>
>
>
>
>
>enum Moods {JOY, SADNESS, SURPRISE, ANGER, FEAR, DISGUST, N_MOODS
> , APOLOGY= N_MOODS, TAUNT, moodNot, moodVery, MOOD_COUNT};
>const char* moodName [MOOD_COUNT] = {"joy","sadness","surprise","anger"
> ,"fear","disgust", "apology", "taunt", "not", "very"};
>const Bstring moodFlag [N_MOODS] = {
> ":JOYFUL", ":SADDEN", ":SHOCKING", ":ANGERED", ":FEARFUL", ":DISGUSTING"};
>
>double moodStart [MOOD_COUNT] = {0.2,-0.1,0.1, -0.1,-0.1,-0.3};
>double moodValue [MOOD_COUNT];
>int moodDelta [MOOD_COUNT];
>int moodMost = 0;
>int moodForce = 0;
>static const double moodDrift = 0.9;
>static const double moodBoost = 1.2;
>static const double moodWrong = 0.4;
>void __attribute__((stdcall)) moodDecay ();
>void __attribute__((stdcall)) moodLoad ();
>void __attribute__((stdcall)) moodUpdate (const Bstring& agument);
>
>
>
>void moodLoad () {
> for (int m= 0; m < N_MOODS; ++m)
> moodValue[ m] = moodStart[ m];
> Bstring s;
> moodShow( s);
> wo("mood init %s\n", s.c_str());
>}
>int moodFind (const Bstring& target) {
> int probe= 0;
> do {
> if (target == moodName[ probe]) break;
> ++probe;
> }while (probe < MOOD_COUNT);
> return probe;
>}
># 822 "apFact.cpp"
>void moodUpdate () {
> if (moodMost == ANGER) {
> if (moodDelta[ APOLOGY] && moodDelta[ ANGER] > 4) moodDelta[ ANGER] -= 3;
> if (moodDelta[ TAUNT]) moodDelta[ ANGER] += 1;
> }
> int m= 0;
> do {
> const int pos = moodDelta[ m];
> const int much = abs( pos);
> if (much == 0) {
> moodValue[ m] *= moodDrift;
> }else if (moodValue[ m] * pos < 0) {
> if (much > 1) moodValue[ m] = 0;
> moodValue[ m] = pos * moodWrong;
> }else if (moodValue[m] == 0) {
> moodValue[ m] = 3 * much;
> }else{
> moodValue[ m] *= pow( moodBoost, much);
> }
> ++m;
> }while (m < N_MOODS);
>
> int mx = 0;
> for (int j = 1; j < N_MOODS; ++j) {
> if (moodValue[ j] > moodValue[ mx]) mx = j;
> }
> moodMost = mx;
> moodForce = 0;
> memset( moodDelta, 0, sizeof( moodDelta));
>}
>void moodDecay () {
> for (int m= 0; m < N_MOODS; ++m)
> moodValue[ m] *= moodDrift;
>}
>
>
>
>
>Bstring moodSense (const Bstring& augment) {
> static const Bstring delims( Bstring::white + Bstring(".$,"));
> Seqp toks;
> split( toks, augment, delims);
> int pos = 1, much= 1, most= -1;
> for (int a = 0; a < toks.size(); ++a) {
> Bstring& s( toks[ a]);
> int m = moodFind( s);
> if (m < N_MOODS) {
> moodDelta[m] = pos * much;
> if (most < 0 || abs( moodDelta[m]) > abs( moodDelta[ most])) {
> most= m;
> }
> moodForce= pos= much= 1;
> continue;
> }
> if (m == moodNot ) pos *= -1;
> if (m == moodVery) ++much;
> }
> return most < 0? "" : moodFlag[ most];
>}
>
>
>Bstring moodSense_OLD (const Bstring& augment) {
> TokBag toks( augment);
> int pos = 1, much= 1, most= -1;
> for (int a = 0; a < toks.size(); ++a) {
> Bstring s;
> toks.get( a, s);
> int m = moodFind( s);
> if (m < N_MOODS) {
> moodDelta[m] = pos * much;
> if (most < 0 || abs( moodDelta[m]) > abs( moodDelta[ most])) {
> most= m;
> }
> moodForce= pos= much= 1;
> continue;
> }
> if (m == moodNot ) pos *= -1;
> if (m == moodVery) ++much;
> }
> return most < 0? "" : moodFlag[ most];
>}
>void moodFeel (Bstring& dest) {
> dest << moodName[ moodMost];
>}
>
>
>void moodShow (Bstring& dest) {
> char buf[ 5 * N_MOODS];
> char *b = buf;
> for (int m= 0; m < N_MOODS; ++m) {
> int v = int( 100 * moodValue[ m] + 0.5);
> if (v < 0) {*b++ = '-'; v= -v;
> }else{ *b++ = '+';}
> if (v >= 100) {
> *b++ = v / 100 + '0';
> v %= 100;
> }
> *b++ = v / 10 + '0';
> *b++ = v % 10 + '0';
> }
> *b = 0;
> dest += buf;
>}
>
>
>
>
>
>
>void getAffect (Bstring& msg) {
> static const boost::regex multBlank("\\s\\s");
> static int prevMood = -1;
> msg.replace( multBlank, " ");
>
> if (moodForce || msg.search("^if\\s")) {
>
> }else{
> if (msg.search("/mood\\s")) {
> moodSense( msg);
> }else{
> affect.sense( moodDelta, msg);
> }
> }
> moodUpdate();
> if (Option('S')) {
> Bstring s;
> moodShow( s);
> wo("mood %s\n", s.c_str());
> }
>
> Bstring act;
> if (moodValue[ moodMost] >= 3) {
># 968 "apFact.cpp"
> if (moodMost != prevMood) {
> prevMood = moodMost;
> if (msg.empty())
> bot_responder( msg, moodFlag[ moodMost]);
> }
>
> }
> if (act.empty() && ! msg.search("/act\\s")) {
>
>
> if (ourAgent == 2) pickAxe.sense( act, msg);
> else pickHap.sense( act, msg);
> }
> if (! act.empty()) {
> act.insert( 0, "/act ");
> act += ". ";
> msg.insert( 0, act);
> }
>}
># 1004 "apFact.cpp"
>void Affector::add (const Bstring& line) {
>
> Bstring tail;
> if (isspace( line[0])) {
> tail = line;
> }else{
> curHead = line;
> curHead.split( tail);
> curHead.replaceUnder();
> }
> const int mood( moodFind( curHead));
> if (mood >= MOOD_COUNT)
> ABEND("unknown mood %s", curHead.c_str());
> affect[ curHead] = mood;
> TokBag toks( tail);
> for (int t = 0; t < toks.size(); ++t) {
> Bstring w;
> toks.get( t, w);
>
> affect[ w] = mood;
> }
>}
>
>void Affector::sense (int feel[], const Bstring& line) const {
>
> Elicit::const_iterator x = affect.begin();
> while (x != affect.end()) {
> const Bstring& s( x->first);
>
> if (line.search( s)) {
> ++ feel[ x->second];
> }
> ++x;
> }
>}
>
>
>
>void Effect::add (const Bstring& line) {
>
> Bstring tail;
> if (isspace( line[0])) {
> tail = line;
> }else{
> Bstring head( line);
> head.split( tail);
> head.replaceUnder();
> curHead = strNew( head.c_str());
> }
> TokBag toks( tail);
> for (int t = 0; t < toks.size(); ++t) {
> Bstring w;
> toks.get( t, w);
> w.replaceUnder();
> if (w[0] == '~') {
> w.erase( 0, 1);
> }else{
> w.insert("\\b");
> w += "\\b";
> }
> boost::regex* rx = new boost::regex( w, boost::regex::icase);
>
> Element v( rx, curHead);
> effect.push_back( v);
> }
>}
>
>
>
>
>
>void Effect::sense (Bstring& dest, const Bstring& msg) const {
> Elicit::const_iterator x = effect.begin();
> while (x != effect.end()) {
>
> if (msg.search( *(x->first))) {
> dest << x->second;
> break;
> }
> ++x;
> }
>
>}
># 1097 "apFact.cpp"
>class Notion
>{
> FactBag* bag;
> double relevance;
> int f;
>public:
> Notion () : bag(0), f(0), relevance(0) {}
> const Bstring& get () const {return bag->get( f);}
> void use () const {bag->use( f);}
> FactRef ref () const {return FactRef( bag, f);}
> double score () const {return relevance;}
> double metric () const;
> void bump (double x) {relevance += x;}
> static void add (FactBag& bag, int f, double relate);
> static int choose();
> static void clear ();
> static bool empty ();
> static const Bstring& str (int j);
> static const Bstring& str ();
> static void show (int j);
> static double score (int j);
> static double best ();
> static FactRef champ ();
>};
>
>
>
>
>
>double Query::like (const Signature& fSign) const {
> if (! alts.match( fSign)) {
> return 0;
> }
> wo(" qh {%s} {%s}\n", base.toStr().c_str(), fSign.toStr().c_str());
> Signature::const_iterator x = base.begin();
> double score= 0;
> while (x != base.end()) {
> double info = 1 + 2.0 / glossary.occurs( *x);
> if (fSign.has( *x)) {
> score += info;
> wo(" qf %4d %9.1f {%s}\n", *x, info, glossary.get( *x));
> }else if (fSign.match( glossary.gang( *x))) {
> score += 0.9 * info;
> wo(" qg %4d %9.1f {%s}\n", *x, 0.9*info, glossary.get( *x));
> }
> ++x;
> }
> return 100.0 * score / base.size();
>}
>
>double Query::add (const Bstring& from) {
> msg << ' ' << from;
>
> changeToSubject( msg);
> changeYourForMyEtc( msg);
> Bstring dest;
> extractRelevantText( dest, msg);
> if (Option('S')) wo(" rei {%s} {%s}\n", dest.c_str(), msg.c_str());
> if (dest.empty()) dest= msg;
> if (msg.search("\\b"+userName+"\\b")) checkName= true;
> double score = expand( dest);
> if (Option('S')) {
> wo(" %.2f msg{%s} sub{%s}\n", score, msg.c_str(), Subject.c_str());
> }
> return score;
>}
>
>
>
>
>double Query::expand (const Bstring& msg) {
> CiteList words( msg);
> CiteList::const_iterator c = words.begin();
> while (c != words.end()) {
> wo(" exq %4d{%s}+{%s}\n", *c, glossary.get(*c)
> , glossary.gang( *c).toStr().c_str());
> base.add( *c);
> alts.add( glossary.gang( *c));
> ++c;
> }
> if (Option('S')) {
> wo(" setBase {%s} {%s}\n", base.toStr().c_str(), alts.toStr().c_str());
> }
> return base.size();
>}
>
>
>
>double Query::open (const Bstring& from, bool wantName) {
> searchMany = true;
> inferringAllowed = false;
> checkName = wantName;
> Notion::clear();
> base.clear();
> alts.clear();
> outMessage.clear();
> newSubject.clear();
> msg.clear();
> return add( from);
>}
>
>Query curQ;
>int bestNotion;
>int notionCount;
>int outNotion;
>bool NewQuery;
>const int mxREL = 40;
>Notion notions[ mxREL];
>
>
>inline FactRef Notion::champ () {return notions[ bestNotion].ref ();}
>inline double Notion::best () {return notions[ bestNotion].score();}
>inline double Notion::score (int j) {return notions[j].score();}
>inline const Bstring& Notion::str (int j) {return notions[j].get();}
>inline const Bstring& Notion::str () {return str( bestNotion);}
>inline bool Notion::empty () {return notionCount <= 0;}
>
>
>
>double Notion::metric () const {
>
>
>
>
> return exp( relevance/10);
>}
>
>int Notion::choose () {
> if (notionCount <= 0) return -1;
> double sum = 0;
> for (int j= 0; j < notionCount; ++j) {
> sum += notions[j].metric();
> }
> double fraction = uniFrand();
> double select = sum * fraction;
> wo(" noC %.2f * %.1f%% = %.2f\n", sum, 100*fraction, select);
> sum = 0;
> for (int j= 0; j < notionCount; ++j) {
> const Notion& n( notions[j]);
> sum += n.metric();
> const Bstring lead( n.get().substr(0,30));
> wo(" noJ %-2d %4d %4.1f %7g %7g {%s}\n"
> , j, n.f, n.score(), n.metric(), sum, lead.c_str());
> if (sum >= select) return j;
> }
> (static_cast<void> ((false) ? 0 : (__assert_fail ("false", "apFact.cpp", 1242, __PRETTY_FUNCTION__), 0)));
> return 0;
>}
>void Notion::add (FactBag& bag, int f, double relate) {
> if (notionCount >= mxREL) return;
> if (relate < 0) relate = 0;
> if (relate > 100) relate = 100;
> if (curQ.checkName) {
> if (Statement.search("\\byou(r[se]?)?")) {
> relate += 70;
> } }
> Notion& n( notions[ notionCount]);
> n.bag = &bag;
> n.f = f;
> n.relevance = relate;
> if (relate > best()) bestNotion = notionCount;
> ++notionCount;
>}
>void Notion::clear () {
> bestNotion= notionCount= 0;
> notions[0].bag = 0;
> notions[0].f = factNone;
> notions[0].relevance = 0;
> NewQuery = false;
> outNotion = -1;
>}
>void Notion::show (int j) {
> const Notion& n( notions[j]);
> const Bstring lead( n.get().substr(0,40));
> wo("%-2d %2d:%-4d %5.1f {%s}\n", j
> , n.bag->source(n.f), n.f, n.score(), lead.c_str());
>}
>
>
>
>
>const char simplifyWords[] = "please you_tell_me can will tell_me wont won't";
>const char splitNoise[] = "subject there the that she he how they you "
> "going what Why Where When Who we";
>
>Remover simplify;
>Remover queryNoise;
>
>
>const boost::regex querySplit (
> "(.*)\\bare|has|is|was|were|could|will|might|may|can\\b(.*)"
> , boost::regex::icase);
>const boost::regex dativeWords(
> "\\b(and|when|if|from|or|then|where|a|about|how|I)\\b|[.,!]"
> , boost::regex::icase);
>const boost::regex leaveIts("\\b(it (is|has) .+ that)\\b");
>
>void SimplifyQuestion (Bstring& msg) {simplify.execute( msg);}
>
>
>
>void changeToSubject (Bstring& msg) {
> if (Subject.empty()) return;
> if (msg.search( Subject)) return;
> if (Subject == userName) return;
> static const boost::regex she("\\bs?he\\b", boost::regex::icase);
> msg.replace( she, Subject);
> Bstring plural( Subject);
> static const boost::regex art("A .+" , boost::regex::icase);
> static const boost::regex ant("An .+", boost::regex::icase);
> if (plural.match( art)) {
> plural = Subject.substr( 2) + "s";
> }else if (plural.match( ant)) {
> plural = Subject.substr( 3) + "s";
> }
> msg.replace("\\bthey\\b", plural);
>
>
>
> if (msg.search( leaveIts)) return;
> if (msg.search("\\bit take (the|for)\\b")) return;
> if (msg.search("\\bwill it be in\\b")) return;
> msg.replace("\\bit\\b", Subject);
>}
>
>template< typename T>
>void assign (vector< T>& dest, const set<T>& rhs) {
> set<Bstring>::const_iterator x = rhs.begin();
> while (x != rhs.end()) {
> dest.push_back( *x);
> ++x;
> }
>}
>void initFroler () {
> simplify .init( simplifyWords);
> queryNoise.init( splitNoise);
>}
>
>bool filterNoise (const Bstring& msg) {
>
> if (queryNoise.in( msg)) return false;
> newSubject = msg;
> return true;
>}
>
>
>void RemoveSet::execute (Bstring& dest) const {
> set<Bstring>::const_iterator x = targets.begin();
> while (x != targets.end()) {
> dest.replaceWord( *x, "");
> ++x;
> }
> dest.trim();
>
>}
>
>void Remover::init (const char* text) {
> Bstring pat( text);
> pat.trim();
> if (pat.empty()) return;
> pat.replace(" ", "|");
> pat.replaceUnder();
> pat.insert("\\b(");
> pat += ")\\b";
> rxPat.assign( pat, boost::regex::icase);
>}
>void RemoveSet::init (const char* text, bool wordOnly) {
> vector< Bstring> words;
> stringTok( words, Statement);
> for (int j= 0; j < words.size(); ++j) {
> Bstring dest( words[j]);
> dest.trim();
> if (dest.empty()) continue;
> if (dest[0] == '*') continue;
> if (wordOnly) {
> dest.insert("\\b");
> dest += "\\b";
> }
> dest.replaceUnder();
> targets.insert( dest);
> }
>}
>
>
>
>void Bstring::changeToClient () {
> if (empty()) return;
> vector< Bstring> words;
> stringTok( words, *this);
> words.push_back("");
> clear();
> bool inQuote= false;
> int N = 0;
> while (N < words.size()) {
> if (words[N] == "\"" || words[N] == "'") {
> inQuote = ! inQuote;
> }
> if (! inQuote) {
> if (words[N] == "my" || words[N] == "mine") {
> words[N] = userName + "'s";
>
> }else if (words[N] == "I" && words[N+1] == "am") {
> words[N] = userName;
> words[N+1] = "is";
>
> }else if (words[N] == "I" && words[N+1] == "have") {
> words[N] = userName;
> words[N+1] = "has";
>
> }else if (words[N] == "am" && words[N+1] == "I") {
> words[N] = "is"; words[N+1] = userName;
>
> }else if (words[N] == "I" && words[N+1].search("\\w+")) {
> words[N] = userName;
>
> }else if (words[N] == "me") {
> words[N] = userName;
> }
> }
> *this += words[N];
> *this += ' ';
> ++N;
> }
> trim();
>}
>
>
>
>void Bstring::changeFromClient () {
> replace("\\bI is\\b", "I am");
> Bstring bu("\\b");
> bu += userName;
> replace( bu+" is\\b" , "you are");
> replace( bu+"'s\\b" , "your");
> replace( bu+"\\b" , "you");
> replace( "\\byou has\\b", "you have");
>
>}
># 1453 "apFact.cpp"
>void changeYourForMyEtc (Bstring& msg) {
> if (msg.empty()) return;
> vector< Bstring> words;
> words.push_back("");
> stringTok( words, msg);
> words.push_back("");
> msg = "";
> bool inQuotes= false;
> int N = 1;
> do {
> Bstring& w( words[N]);
> if (w.empty()) break;
> if (w[0] == '"' || w[0] == '\'') inQuotes = ! inQuotes;
> if (! inQuotes) {
> if (w == "yours" ) {w = "mine";
> }else if (w == "mine") {w = "yours";
> }else if (w == "you" ) {
> if (words[N + 1].search( dativeWords)) w = "me";
> else w = "I";
> }else if (w == "I" ) {w = "you";
> }else if (w == "me" ) {w = "you";
> }else if (w == "are" ) {
> if (words[N + 1] == "you" || words[N-1] == "I") {
> w = "am";
> }
> }else if (w == "am") {
> static const boost::regex digits("\\D+");
> if (words[N - 1].match( digits)) {
> w = "are";
> }
> }else if (w == "my") {w = "your";
> }else if (w == "your") {w = "my";
> }
> }
> msg += w + " ";
> ++N;
> }while(1);
> msg.trim();
>}
># 1526 "apFact.cpp"
>Roler dateTime("dateTime");
>Roler deGossip("deGossip");
>Roler gender ("gender" );
>Roler person ("person" );
>Roler person2 ("person2");
>Roler personq ("personq");
>Roler personf ("personf");
>Roler speller ("speller");
>
>
>void initRolers () {
> roles["agenda" ] = &agenda;
> roles["affect" ] = &affect;
> roles["client" ] = &client;
> roles["dates" ] = &dateTime;
> roles["deGossip"] = &deGossip;
> roles["diary" ] = &diary;
> roles["facts" ] = &facts;
> roles["gender" ] = &gender;
> roles["haptek" ] = &pickHap;
> roles["jokes" ] = &jokes;
> roles["lexicon" ] = &glossary;
> roles["msagent" ] = &pickAxe;
> roles["person" ] = &person;
> roles["person2" ] = &person2;
> roles["personf" ] = &personf;
> roles["personq" ] = &personq;
> roles["proper" ] = &properNoun;
> roles["skip" ] = &skipper;
> roles["speller" ] = &speller;
> roles["smalltalk"]= &trivia;
> roles["trivia" ] = &trivia;
> roles["wordMath"] = &wordMath;
>}
>
>
>
>
>
>void Roler::add (const Bstring& o, const Bstring& n) {
>
> (static_cast<void> ((false) ? 0 : (__assert_fail ("false", "apFact.cpp", 1567, __PRETTY_FUNCTION__), 0)));
>
>
>
>
>
>
>
>}
>
>
>
>
>void Roler::add (const Bstring& s) {
> Bstring tail;
> Bstring head( s);
> head.split( tail);
> tail.trim();
> tail.replace("\\^","~");
> head.replaceUnder();
> if (head[0] == '~') {
> head.erase( 0, 1);
> }else{
> head.insert("\\b");
> head += "\\b";
> }
> old.push_back( new boost::regex( head, boost::regex::icase));
> nue.push_back( tail);
>}
>
>void Roler::dsub (Bstring& dest) const {
> Bstring was( dest);
> for (int j= 0; j < old.size(); ++j) {
> if (Option('V') > 6)
> wo("r::dsub %s.%d {%s}{%s}\n",me,j,nue[j].c_str(),dest.c_str());
>
> dest.replace( *old[j], nue[j]);
>
>
>
>
>
>
> }
> dest.trim();
> if (Option('V') > 5) wo("dsub %s {%s} => {%s}\n", me, was.c_str(), dest.c_str());
>}
># 1640 "apFact.cpp"
>template <typename Container>
>void stringTok (Container &dest, const Bstring& in) {
> const size_t len = in.size();
> size_t j = 0;
> int begin= -1;
> while (j < len) {
> int ch = in[ j];
> if (ch == '\'' && begin < j) {
> ;
> }else if (isalnum( ch) || ch == '-' || ch == '_') {
> if (begin < 0) begin= j;
> }else{
> if (begin >= 0) {
> dest.push_back( in.substr( begin, j-begin));
> }
> begin= -1;
> }
> ++j;
> }
> if (begin >= 0) {
> dest.push_back( in.substr( begin, len-begin));
> }
> dest.push_back("");
>}
># 1675 "apFact.cpp"
>bool contains (const vector<Bstring> data, const Bstring& target) {
> for (int j= 0; j < data.size(); ++j) {
> if (data[j] == target) return true;
> }
> return false;
>}
>
>template <typename T>
>bool contains (const T data[], int len, const T& target) {
> for (int j= 0; j < len; ++j) {
> if (data[j] == target) return true;
> }
> return false;
>}
>
>inline bool setIf (const Bstring& from, const char* pat) {
> const boost::regex rx( pat, boost::regex::icase);
> return from.extract( twixMsg, rx);
>}
>
>
>void AddThing (const Bstring& noun) {
> if (noun.empty()) return;
> Cite n = glossary.lookup( noun);
> if (n < citeTrivial) return;
> wo("addThing %-3d %d %s\n", n, citeTrivial, noun.c_str());
> if (things.contains( n)) return;
> things.push( n);
>}
>
>void pushThings (const Bstring& msg) {
> CiteList words( msg);
> const CiteList::const_iterator end = words.end();
> CiteList::const_iterator x = words.begin();
> while (x != end) {
> if (*x >= citeTrivial) {
> if (Option('S'))
> wo("pushThing %-5d %s\n", *x, glossary.get( *x));
> if (! things.contains( *x))
> things.push( *x);
> }
> ++x;
> }
>}
>
>
>
>
>
>
>const boost::regex fourWords("\\w+ \\w+ \\w+ \\w+");
>
>void extractThings (const Bstring& from) {
> Bstring noun;
> twixMsg = " ";
> twixMsg += from;
> if (setIf( noun, "\\bTHE (.+) is:? ")
> || setIf( noun, "\\bAN? (.+) is:? ")
> || setIf( noun, "\\bTHE (.+) has ")
> || setIf( noun, "\\bIS AN? (.+) who ")
> || setIf( noun, "\\bAN? (.+) has ")) goto GetIt;
> if (twixMsg.search("[?]")) return;
> if (setIf( noun, "(.+) is the ")) {
> if (noun.match( fourWords)) setIf( noun, " is the (.+)");
> goto GetIt;
> }
> if (setIf( noun, "\\b(.+) is a noun\\b")
> || setIf( noun, "\\b(.+) is an? ")
> || setIf( noun, "\\b(.+) is ")
> || setIf( noun, "\\bAN? (.+) that|which is ")
> || setIf( noun, "\\bAN? (.+) is ")
> || setIf( noun, "\\byour (.+)")
> || setIf( noun, "\\bmy (.+)")) goto GetIt;
> return;
>
>GetIt:
> if (noun.match( fourWords)) return;
>StripLoop:
> if (noun.size() < 2) return;
> if (! isalnum( noun.last())) {
> noun.erase( noun.size() - 1);
> goto StripLoop;
> }
> if (noun == "it") return;
> if (Option('S'))
> wo(" extractThings {%s}\n", noun.c_str());
> if (noun.search("[.,].*[a-z]$")) {
>
> wo(" won't add {%s}\n", noun.c_str());
> return;
> }
> AddThing( noun);
> return;
>}
># 1792 "apFact.cpp"
>void AddQuestionMark (Bstring& dest) {
> dest += '?';
>}
>
>void getLatestSubject (const Bstring& query) {
> static Bstring LastSubject;
> Bstring sMessage;
>
>
>
> sMessage = query;
> sMessage.changeToClient();
> changeToSubject( sMessage);
> changeYourForMyEtc( sMessage);
> getSubject( sMessage);
>
>
>
>
>
>
> if (sMessage == query) return;
>
> Bstring Temp = Subject;
> Bstring Temp2 = BareSubject;
> getSubject( sMessage);
> Bstring userSubj = Subject;
> Subject = Temp;
> BareSubject = Temp2;
> if (userSubj.empty()) return;
>
> int P1 = query.find( userSubj);
> if (P1 == string::npos) return;
> int P2 = sMessage.find( userSubj);
> if (P2 == string::npos) return;
> if (P1 < P2) {Subject= userSubj; BareSubject= Temp2;}
>}
># 1860 "apFact.cpp"
>const Bstring& FactBag::getRand() {
> factDial= rand();
> Notion::add( *this, factDial, 0.5);
> use( factDial);
> return gloss[ factDial];
>}
>int FactBag::rand() {
> return factDial = 1 + randInt( size()-1);
>}
>
>
>
>
>
>
>const int mxBACK = 30;
>int dialReply;
>int dialMessage;
>Bstring LastuserInput;
>FactRef LastReplies [mxBACK];
>FactRef LastMessages[mxBACK];
>
>
>void replyRelevant (Bstring& reply, Bstring& command) {
> time_t startTime = time(0);
> if (Option('S')) wo("aPad {%s}\n", command.c_str());
> Bstring query;
> command.split( query);
> curQ.open( query);
> const Bstring prevSubject( Subject);
> pushThings( query);
> getLatestSubject( query);
> curQ.searchAll( query == LastuserInput);
>
> if (command == "who") {
> findPersonal( reply);
> reply.changeFromClient();
> return;
> }
> if (query.empty() || command.empty() || command == "joke") {
> if (uniFrand() < 0.04) {
> bot_responder( reply, ":INSULT");
> return;
> }
> curQ.searchAll( false);
> if (uniFrand() < 0.95) jokes.getRand(); else trivia.getRand();
> return;
> }
> if (command == "educate") {
> findRemarkable();
> }else{
>
> if (command != "any") {
> wo(" aPad not any {%s}{%s}\n", command.c_str(), query.c_str());
> }
> if (query.empty()) {
> wo(" aPad query empty {%s}\n", command.c_str());
> return;
> }
> findRelevantFacts();
> }
> curQ.select();
> Subject = prevSubject;
> LastuserInput = query;
>
> if (outNotion >= 0) {
> outMessage = notions[ outNotion].get();
> notions[ outNotion].use();
> if (NewQuery && Notion::best() < 40)
> outMessage = "Not sure, but I think " + outMessage;
> reply= outMessage;
> reply.changeFromClient();
> }
> if (Option('S')) {
>
>
> double elapsed = difftime( time(0), startTime);
> if (elapsed > 1)
> wo("Search time:- %f\n", elapsed);
> }
>}
># 1949 "apFact.cpp"
>void doFetch (Bstring& dest, Bstring& subject) {
> curQ.open( subject);
> curQ.searchAll( true);
> client.getRelevant( 1, curQ);
>
> outNotion = bestNotion;
> if (Notion::best() < 1) {
> dest = ":BADFACT ";
> dest += subject;
> }else{
> notions[ outNotion].use();
> const Bstring& b( notions[ outNotion].str());
> dest = ":GOTFACT ";
> dest += b;
> }
>}
>
>
>
>void findPersonal (Bstring& reply) {
> (static_cast<void> ((Notion::empty()) ? 0 : (__assert_fail ("Notion::empty()", "apFact.cpp", 1969, __PRETTY_FUNCTION__), 0)));
> curQ.checkName = true;
> client.getRelevant( 2.1, curQ);
>
> bool okay = ! Notion::empty();
> if (okay) {
> Notion& n( notions[ bestNotion]);
>
> Bstring b( n.get());
> n.use();
> if (n.score() < 10) {
> saved.push_back( b);
> okay = false;
> }else{
> reply += b;
> }
> }
> if (! okay) {
>
> Bstring q(":XDICT ");
> q = ":ASK FOR INFO ";
> Bstring ask( curQ.msg);
> ask.changeToClient();
> q += ask;
> bot_responder( reply, q);
> }
>}
>
>
>void findRelevant () {
> Bstring query( userTidy);
> curQ.open( userTidy);
> extractThings( userTidy);
> getLatestSubject( userTidy);
> if (Subject.empty()) Subject= "hello";
> findRelevantFacts();
>}
>void showRelevant () {
> int n= 0;
> wo(" %d relevant facts ---------------\n", notionCount);
> for (int j= 0; j < notionCount; ++j) {
> if (Notion::score(j) < 0.01) continue;
> ++n;
> Notion::show(j);
> }
>}
>void showDebugNotion (int j) {
> wo("chose ");
> Notion::show( j);
>}
>
>
>
>
>void Query::select () const {
>
>
>
>
>
> if (sentTerm == '?') {
> if (msg == LastuserInput) {
> if (Notion::best() < 40) goto NothingElseToSay;
> outNotion = bestNotion;
> }else{
> if (! Notion::empty()) return;
> dialReply = 0;
> (static_cast<void> ((false) ? 0 : (__assert_fail ("false", "apFact.cpp", 2036, __PRETTY_FUNCTION__), 0)));
> if (Notion::best() < 40) {outMessage = ""; return;}
> outNotion = bestNotion;
> NewQuery = true;
> }
>
> LastReplies[dialReply] = Notion::champ();
> if (++dialReply >= sizeof(LastReplies)) dialReply = 0;
>
> }else{
> int N = Notion::choose();
> outNotion = N;
> if (N < 0) goto NothingElseToSay;
>
>
>
>
>
>
> }
> LastMessages[ dialMessage] = notions[ outNotion].ref();
> if (++dialMessage >= mxBACK) dialMessage = 0;
> if (Option('S')) {
> showDebugNotion( outNotion);
> }
>
>
> if (curQ.inferringAllowed) {
># 2072 "apFact.cpp"
> }
> return;
>
>NothingElseToSay:
> if (sentTerm == '?') {
> outMessage = ":DONTKNOW";
> }
>}
>
>
>void GetCondition () {
>}
>void extractRelevantText (Bstring& dest, const Bstring& from) {
> twixMsg = from;
>
>
> if (setIf( dest, " info(?:rmation)? (?:about|on) (.+)")
> || setIf( dest, " data (?:about|on) (.+)")
> || setIf( dest, " low down on (.+)")
> || setIf( dest, " run down on (.+)")
> || setIf( dest, " dirt on (.+)")
> || setIf( dest, " facts on (.+)")
> || setIf( dest, " gossip on (.+)")
> || setIf( dest, " knowledge of (.+)")
> || setIf( dest, " tell \\w+ about (.+)")
> || setIf( dest, " know.* about (.+)")
> || setIf( dest, "\\bdo i know (.+)")) return;
> Bstring s( twixMsg);
> extractThings( s);
> dest= things.toString();
>}
>
>
>
>
>static const boost::regex remarkable(
> "(holds the world record|in the world|in history"
> "|set the world record|the first man|the first person|the first woman"
> "|known to man|broke the world record|has the world record"
> "|holds the record|is the biggest|is the largest|is the smallest"
> "|is the fastest|is the strongest|is the heaviest|is the quickest"
> "|has an usual|has an extraordinary|is the cleverest|is the smartest"
> "|is the most|has the most|has an amazing|was assassinated"
> "|explode|exploded|exploding|maximum|the highest|holds the record)"
> , boost::regex::icase);
>
>
>void findRemarkable () {
> if (uniFrand() < 0.1) {
> trivia.getMatch( 40, remarkable);
> }
> if (uniFrand() < 0.3) {
> jokes.getMatch( 40, remarkable);
> }
> facts.getMatch( 40, remarkable);
> smalltalk.getMatch( 30, remarkable);
> if (Notion::empty()) {
> Notion::add( smalltalk, smalltalk.rand(), 11);
> }
>}
>
>
>void FactBag::getMatch (double relate, const boost::regex& pat) {
> int factLast = factDial + size()/2;
> if (factLast > size()) factLast -= size();
> do {
> DoEvents();
>
> if (factDial == factLast) break;
> const int aFact( next());
> if (aFact == factNone) continue;
> Statement = get( aFact);
> (static_cast<void> ((! Statement.empty()) ? 0 : (__assert_fail ("! Statement.empty()", "apFact.cpp", 2144, __PRETTY_FUNCTION__), 0)));
> if (Statement.search( pat)) {
> if (Option('S'))
> wo("s= %d{%s}\n", aFact, Statement.c_str());
> Notion::add( *this, aFact, relate);
> break;
> }
> }while(1);
>}
>
>
>double someSubjAltThing (const Signature::const_iterator N) {
> const Signature& gang( glossary.gang( *N));
> Signature::const_iterator W = gang.begin();
> while (W != gang.end()) {
> Bstring begAlt("\\b");
> begAlt << glossary.get( *W);
> Bstring padAlt( begAlt);
> padAlt << "\\b";
> if (Statement.search( padAlt)) {
> return 9;
> }
> if (Statement.search( begAlt)) {
> const Phrase& p( glossary.phrase( *W));
> return 3 + p.size();
> break;
> }
> ++W;
> }
> return 0;
>}
>
>
>
>
>
>
>void FactBag::getRelevant (double heft, const Query& need) {
> if (Option('S') > 1) {
> wo("--- SRS %-9s %.1f\n", me, heft, need.toStr().c_str());
> }
> if (factDial >= size()) factDial= 0;
> int factLast = factDial;
> if (factLast >= size()) factLast -= size();
> do {
> DoEvents();
>
> if (++factDial >= size()) factDial= 0;
> if (factDial == factLast) break;
> const int aFact= factDial;
> if (aFact == factNone) continue;
> Statement = get( aFact);
> (static_cast<void> ((! Statement.empty()) ? 0 : (__assert_fail ("! Statement.empty()", "apFact.cpp", 2196, __PRETTY_FUNCTION__), 0)));
>
>
> double relate = curQ.like( sign( aFact));
> if (relate < 2) continue;
>
> relate *= heft * recency( aFact);
> if (Option('S') > 2) {
> Bstring lead( Statement.substr(0,50));
> wo(" n+ %-2d %-4d %.2f {%s}\n"
> , notionCount, aFact, relate, lead.c_str());
> }
> if (relate < (10 + (notionCount / 2))) continue;
>
> Notion::add( *this, aFact, relate);
> if (notionCount >= mxREL) {
>
> if (Option('S') > 2)
> wo("%d relevant statements\n", notionCount);
>
> break;
> }
>
>
>
> if (! curQ.searchAll() && relate > 90) break;
> }while(1);
>}
># 2318 "apFact.cpp"
>double FactBag::recency (int aFact) {
> int n = lastBeat[ aFact];
> if (n <= 0) return 1;
> if (n >= theBeat) {
> wo("lastBeat[%d] %d >= %d theBeat\n", aFact, n, theBeat);
> n = theBeat;
> }
> return 1/(1 + exp(5 - (theBeat - n)));
>}
>
>
>
>
>
>void findRelevantFacts () {
> (static_cast<void> ((Notion::empty()) ? 0 : (__assert_fail ("Notion::empty()", "apFact.cpp", 2333, __PRETTY_FUNCTION__), 0)));
>
>
>
> int tryNumber = 1;
> do {
> double qSize= curQ.size();
> if (qSize >= 1 || tryNumber >= 4) break;
> ++tryNumber;
> wo("try %d {%s}\n", tryNumber, curQ.msg.c_str());
> if (tryNumber == 2) {curQ.add( botsMessage ); continue;}
> if (tryNumber == 3) {curQ.add( LastInMessage); continue;}
> break;
> }while(1);
> client.getRelevant( 1.1, curQ);
> facts.getRelevant( 1.0, curQ);
> if (Notion::best() < 20) {
> if (uniFrand() < 0.7) jokes.getRelevant( 0.7, curQ);
> if (Notion::best() < 20) {
> trivia.getRelevant( 0.3, curQ);
> }
> }
> return;
>}
># 2392 "apFact.cpp"
>bool doMeans (Bstring& msg) {
> Bstring left, rite;
> static const boost::regex rx("(\\w+)\\s*:\\s*(.+)$", boost::regex::icase);
> if (! msg.extract( left, rite, rx)) return false;
> if (left.empty() || rite.empty()) return false;
> CiteList lhs( left);
> CiteList rhs( rite);
>
>
>
>
> wo(" doMeans {%s}{%s}\n", left.c_str(), rite.c_str());
>}
># 2413 "apFact.cpp"
>bool setVariable (const Bstring& msg) {
> Bstring left, rite;
> static const boost::regex equate("\\s*(\\S+)\\s*=\\s*(\\S+)\\s*$"
> , boost::regex::icase);
> if (! msg.extract( left, rite, equate))
> return false;
> changeYourForMyEtc( left);
> changeYourForMyEtc( rite);
> rite.evalUser();
> rite.trim();
> if (left.empty() || rite.empty()) return false;
> wordMath.add( left, rite);
> if (Option('V') > 4)
> wo(" apSet %s = {%s}\n", left.c_str(), rite.c_str());
> return true;
>}
># 2442 "apFact.cpp"
>bool Bstring::evalUser () {
> wordMath.dsub( *this);
> if (! search("\\d|\\b(?:pi|e|squared?|cubed?|power|percent)\\b")) {
> return false;
> }
>
> if (Option('Q')) wo("ux {%s}\n", c_str());
> uxOpen( *this);
> int fail = 1;
> try {
> fail = uxparse();
> }catch (const xCept& oops) {
> const char* what= uxError( oops.why());
> wo("uxErr %s %s", what, oops.why());
> insert( size()-1, what);
> }
> uxResult.trim();
> const bool okay = fail == 0 && ! uxResult.empty();
> if (okay) {
> *this = uxResult;
> }
> return okay;
>}
>const char* uxError (const char *s) {
> srcBuf[ srcLen] = 0;
> const char* why;
> switch (*s)
> {
>
> case '#': why= 0; ++s; break;
> case ':': why= "Data error"; ++s; break;
> case '&': why= "Value error"; ++s; break;
> case '^': why= "LOGIC BUG"; ++s; break;
> default : why= "";
> }
> return why;
>}
>
>void getAlternativesAndVariables () {
> return;
>
> for (int f= 0; f < facts.size(); ++f) {
> outMessage = "";
> Bstring query = facts.get( f);
> const Bstring& TheStatement( query);
> if (query.empty()) break;
>
>
>
> if (setVariable( query)) continue;
>
> query = TheStatement;
>
> query = TheStatement;
>
> query = TheStatement;
>
> }
>}
>
>void Test () {
> if (userTidy.search("^Test search\\b")) outMessage= "Ok.";
>}
>
>
>void whatIsTheSubject (Bstring& dest, Bstring& msg) {
> Bstring mySubj;
> Bstring oldSub( Subject);
> Bstring reply;
> if (msg == "the") {
> getSubject( botsMessage);
> mySubj = Subject;
> Subject = oldSub;
> if (mySubj.empty()) {
> dest += "I don't know the subject";
> }else{
> if (mySubj == "I") mySubj = "me";
> reply= "The subject is " + mySubj;
> }
> }else if (msg == "we") {
> getSubject( PrevioususerInput);
> mySubj = Subject;
> Subject = oldSub;
> changeYourForMyEtc( mySubj);
> if (mySubj.empty()) {
> dest += "I don't know what we're talking about";
> }else{
> reply = "We're talking about " + mySubj;
> }
> }else if (msg == "I") {
> getSubject( PrevioususerInput);
> mySubj = Subject;
> Subject = oldSub;
> if (mySubj.empty()) {
> dest += "I don't know what you're talking about";
> }else{
> changeYourForMyEtc( mySubj);
> reply = "You're talking about " + mySubj;
> }
>
> }else if (msg == "you") {
> getSubject( botsMessage);
> mySubj = Subject;
> Subject = oldSub;
> if (mySubj.empty()) {
> dest += "I dont know what I am talking about";
> }else{
> if (mySubj == "I") mySubj = "me";
> reply = "I am talking about " + mySubj + ".";
> }
> }
> if (! reply.empty()) {
> reply.changeFromClient();
> dest += reply;
> }
>}
># 2569 "apFact.cpp"
>void getSubject (const Bstring& stmt)
>{
> if (stmt.empty()) return;
> Bstring gMsg( stmt);
> Subject = "";
> BareSubject = "";
>
> if (! gMsg.search("\\w+\\s\\w+.*")) {
>
>
>
> static const boost::regex singleIgnore(
> "(?:which|why|where|when|who|how|did|yes|no|maybe|because|perhaps)\\b"
> , boost::regex::icase);
> static const boost::regex aWord("\\w+", boost::regex::icase);
> if (gMsg.match( singleIgnore)) return;
> if (gMsg.match( aWord)) {newSubject = gMsg; goto Done;}
> return;
> }
># 2596 "apFact.cpp"
> if (gMsg.extract( newSubject, "(.+) means\\b")) goto Done;
> if (gMsg.search("'s \\w+ \\w+")) goto CheckOthers;
>
>
>
>
>
> static const boost::regex wantName (
> "who (?:is it|am I (?:speaking|talking) to)", boost::regex::icase);
> static const boost::regex subjectWord (
> "\\bsubject\\b", boost::regex::icase);
> if (sentTerm == '?' && gMsg.search( subjectWord)) return;
> if (gMsg.match( wantName) ) {
> newSubject = "my name";
> goto Done;
> }
> static const boost::regex isItYou("is (?:it|that) you.+");
> if (gMsg.match( isItYou)) goto PossibleName;
> if (gMsg.extract( newSubject, "\\b(the .+est \\w+)[?]")) goto Done;
> if (gMsg.extract( newSubject, "\\btalk about (.+)")) goto Done;
> if (gMsg.extract( newSubject, "\\btell me about (.+)")) goto Done;
> if (gMsg.extract( newSubject, "\\byou know about (.+)")) goto Done;
> if (checkForThings( newSubject, gMsg)) goto Done;
>
>
> if (gMsg.extract( newSubject, "\\ba (.+)[.?]")) goto CheckOthers;
> if (gMsg.extract( newSubject, "\\bif (.+) goes")) goto Done;
> if (gMsg.extract( newSubject, "Why do you\\b(.+)[?]")) {
> newSubject.insert("The reason why you ");
> goto Done;}
> if (gMsg.extract( newSubject, "Why are you[r]? (.+)[?]")) {
> newSubject.insert("The reason you are ");
> goto Done;}
> if (gMsg.extract( newSubject, "\\bto the (.+)[.]")) goto Done;
>
>
> if (gMsg.extract( newSubject, "\\bThere are no (.+) in")) goto Done;
># 2649 "apFact.cpp"
> if (gMsg.extract( newSubject, "What (.+) is it[?]")) goto Done;
>
>
>CheckOthers:
>
>
>
>Part1: {
> Bstring left, rite;
>
> if (! gMsg.extract( left, rite, querySplit)) goto MaybePerson;
>
>
> const char* None = "";
> try {
> if (filterNoise( left)) goto Done;
> if (rite.last() == '?') rite.erase( rite.size() - 1);
> if (rite.last() == '.') rite.erase( rite.size() - 1);
> }catch (exception& ex) {
> wo("!! OOPS in GuessSubject {%s}{%s} %s\n"
> , left.c_str(), rite.c_str(), ex.what());
> }
> filterNoise( rite);
> }goto Done;
>
>MaybePerson:
> if (gMsg.search("\\bI\\b")) {newSubject = "I"; goto Done;}
> if (gMsg.search("\\byou\\b")) {newSubject = "you"; goto Done;}
>
>PossibleName:
> if (gMsg.search("\\bwho\\b")) return;
> if (gMsg.search("\\bthat\\b")) return;
> newSubject = "My name";
> goto Done;
>
>GetHas: {
> Bstring left, rite;
> static const boost::regex rx("(.*)\\bhas\\b(.*)", boost::regex::icase);
> gMsg.extract(left, rite, rx);
> left.trim();
> newSubject = left + "'s " + rite;
> }
>
>Done:
> if (newSubject.empty()) return;
> Subject = newSubject;
> do {
> int r = Subject[ Subject.size()-1];
> if (strchr(".?!", r) == 0) break;
> Subject.erase( Subject.size() - 1);
> }while(1);
> if (Option('S')) wo("gSJ: {%s}\n", Subject.c_str());
> if (BareSubject.empty()) BareSubject = Subject;
> return;
>}
>
>template <typename T>
>Bstring History< T>::toString () const {
> Bstring dest;
> int x = in;
> while (x != ot) {
> if (x <= 0) x= lim;
> dest += glossary.get( data[--x]);
> dest += ' ';
> }
> if (dest.size() > 0)
> dest.erase( dest.size() - 1);
> return dest;
>}
>template <typename T>
>bool History<T>::contains (const T& target) const {
> int x = in;
> do {
> if (x == ot) return false;
> if (x <= 0) x= lim;
> if (data[--x] == target) return true;
> }while(1);
> return false;
>}
>
>
>
>bool checkForThings (Bstring& dest, const Bstring& msg) {
> if (msg.empty()) return false;
> Statement = msg;
> CiteList IWords( msg);
> if (Option('S')) {
> wo(" cft {%s} ", msg.c_str());
> dump( things);
> }
> const CiteList::const_iterator end = IWords.end();
> CiteList::const_iterator N = IWords.begin();
> do {
> if (N == end) return false;
> if (things.contains( *N)) {
> break;
> }
> ++N;
> }while(1);
>
>
>
> dest = glossary.get( *N);
> BareSubject = dest;
> if (dest == "I" || dest == "me" || dest == "you") return true;
> if (N != IWords.begin()) {
> --N;
> const Bstring& pre( glossary.get( *N));
> if (pre.search("'s$") || pre == "a" || pre == "an" || pre == "the") {
> dest = pre + " " + dest;
> }
> }
> if (Option('S')) wo(" cfu {%s}\n", dest.c_str());
> return true;
>}
>
>
>
>
>bool checkInThings (Bstring& dest, const Bstring& msg) {
># 2789 "apFact.cpp"
>}
># 2805 "apFact.cpp"
>template <typename T>
>void dump (const History<T>& h) {
># 2816 "apFact.cpp"
> Bstring s( h.toString());
> wo(" [%s: %s]\n", h.name(), s.c_str());
>
>}
>
> void showLegomena (const WordFreq& voc, int leg
> , int card, const char* legend) {
> if (card <= 0) return;
> static const boost::regex space(" ");
> wo(" %d %s legomena (%.2f%%)\n", card, legend, 100.0*card/voc.size());
> WordFreq::const_iterator x = voc.begin();
> int n= 0;
> while (x != voc.end()) {
> if (n >= 8) wo("\n");
> if (x->second == leg) {
> Bstring s( x->first);
> s.replace( space, "_");
> int width= (9 + s.size())/9+9;
> wo("%-*s", width, s.c_str());
> }
> ++x;
> }
> wo("\n\n");
>}
>void showVocabulary (const WordFreq& voc,const char* who, const Bstring& what){
> wo(" %d words in %s vocabulary.\n", voc.size(), who);
> if (voc.size() <= 0)
> return;
>
> const WordFreq::const_iterator end = voc.end();
> WordFreq::const_iterator x = voc.begin();
> int hap= 0, dis= 0, tri= 0, occ= 0;
> while (x != end) {
> if (x->second == 1) {++hap;}
> if (x->second == 2) {++dis;}
> if (x->second == 3) {++tri;}
> if (x->second > 3) {
> int width= (15 + 5 + x->first.size())/16*16;
> wo("%4d %-*s", x->second, width-5, x->first.c_str());
> }
> occ += x->second;
> ++x;
> }
> wo("\n\n");
> showLegomena( voc, 3, tri, "tris");
> showLegomena( voc, 2, dis, "dis");
> showLegomena( voc, 1, hap, "hapex");
> int more = voc.size() - (hap + dis + tri);
> wo("%5d of %d > tris (%.2f%%)\n",more,voc.size(),1e2*more/voc.size());
> wo("%5d occurances, average %.1f\n", occ, double(occ)/voc.size());
> int popular = 5 * occ / voc.size();
> wo("--- popular words > quintuple average occurances = %d:\n", popular);
> x = voc.begin();
> int pw= 0, po= 0;
> while (x != end) {
> if (x->second >= popular) {
> ++pw;
> po += x->second;
> int width= (15 + 5 + x->first.size())/16*16;
> wo("%4d %-*s", x->second, width-5, x->first.c_str());
> }
> ++x;
> }
> wo("\n%5d popular words account for %.1f%% of occurrances.\n\n"
> , pw, 100.0*po/occ);
>}
>
>
>
># 1 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iostream" 1 3
># 42 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iostream" 3
> 
># 43 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/iostream" 3
>
>
>
>
>
>namespace std
>{
># 63 "/usr/lib/gcc/i386-redhat-linux/3.4.4/../../../../include/c++/3.4.4/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;
>}
># 2886 "apFact.cpp" 2
>
>
>
>string f (string& incoming) {
> istringstream incoming_stream( incoming);
> string the_word;
> int the_number;
> incoming_stream >> the_word
> >> the_number;
> ostringstream output_stream;
> output_stream << "The word was " << the_word
> << " and 3*N was " << (3*the_number);
> return output_stream.str();
>}

Actions: View

Attachments on bug 232856: 150343