diff --git a/kget/boost.sh b/kget/boost.sh new file mode 100755 index 00000000..b0ab942c --- /dev/null +++ b/kget/boost.sh @@ -0,0 +1,20 @@ +#!/bin/sh + +set -e +boost="" +for dir in "/include" "/usr/include" "/usr/local";do + if [ -d "$dir/boost" ];then + boost="$dir" + fi +done +if [ -z "$boost" ];then + echo "ERROR: unable to find boost headers" + exit 1 +elif [ -z "$(type -p bcp)" ];then + "ERROR: bcp tool not found" + exit 2 +fi +rm -vrf miniboost/ +mkdir -vp miniboost/ + +bcp --boost="$boost" boost/bind miniboost/ \ No newline at end of file diff --git a/libktorrent/CMakeLists.txt b/libktorrent/CMakeLists.txt index bfce33fe..14513de3 100644 --- a/libktorrent/CMakeLists.txt +++ b/libktorrent/CMakeLists.txt @@ -1,9 +1,11 @@ project(LIBKTORRENT) +# boost headers are bundled +include_directories(${PROJECT_SOURCE_DIR}/miniboost) + find_package(KDE4 REQUIRED) find_package(KDE4Internal REQUIRED) find_package(GMP REQUIRED) -find_package(Boost REQUIRED) find_package(QCA2 REQUIRED) set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules;${CMAKE_MODULE_PATH}") @@ -27,7 +29,7 @@ include(CheckTypeSize) #XFS set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${KDE4_ENABLE_EXCEPTIONS}") add_definitions( ${KDE4_DEFINITIONS} ) add_definitions(-DQT_USE_FAST_CONCATENATION -DQT_USE_FAST_OPERATOR_PLUS) -include_directories(${KDE4_INCLUDES} ${LIBKTORRENT_BINARY_DIR} ${LIBKTORRENT_SOURCE_DIR} ${GMP_INCLUDE_DIR} ${Boost_INCLUDE_DIR}) +include_directories(${KDE4_INCLUDES} ${LIBKTORRENT_BINARY_DIR} ${LIBKTORRENT_SOURCE_DIR} ${GMP_INCLUDE_DIR}) set(LIBKTORRENT_VERSION "1.1dev") diff --git a/libktorrent/boost.sh b/libktorrent/boost.sh new file mode 100755 index 00000000..dedf2244 --- /dev/null +++ b/libktorrent/boost.sh @@ -0,0 +1,22 @@ +#!/bin/sh + +set -e +boost="" +for dir in "/include" "/usr/include" "/usr/local";do + if [ -d "$dir/boost" ];then + boost="$dir" + fi +done +if [ -z "$boost" ];then + echo "ERROR: unable to find boost headers" + exit 1 +elif [ -z "$(type -p bcp)" ];then + "ERROR: bcp tool not found" + exit 2 +fi +rm -vrf miniboost/ +mkdir -vp miniboost/ + +bcp --boost="$boost" boost/shared_array.hpp boost/concept_check.hpp \ + boost/scoped_ptr.hpp boost/circular_buffer.hpp \ + miniboost/ \ No newline at end of file diff --git a/libktorrent/miniboost/_G_config.h b/libktorrent/miniboost/_G_config.h new file mode 100644 index 00000000..abec2456 --- /dev/null +++ b/libktorrent/miniboost/_G_config.h @@ -0,0 +1,58 @@ +/* This file is needed by libio to define various configuration parameters. + These are always the same in the GNU C library. */ + +#ifndef _G_config_h +#define _G_config_h 1 + +/* Define types for libio in terms of the standard internal type names. */ + +#include +#define __need_size_t +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T +# define __need_wchar_t +#endif +#define __need_NULL +#include +#define __need_mbstate_t +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T +# define __need_wint_t +#endif +#include +typedef struct +{ + __off_t __pos; + __mbstate_t __state; +} _G_fpos_t; +typedef struct +{ + __off64_t __pos; + __mbstate_t __state; +} _G_fpos64_t; +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T +# include +typedef union +{ + struct __gconv_info __cd; + struct + { + struct __gconv_info __cd; + struct __gconv_step_data __data; + } __combined; +} _G_iconv_t; +#endif + + +/* These library features are always available in the GNU C library. */ +#define _G_va_list __gnuc_va_list + +#define _G_HAVE_MMAP 1 +#define _G_HAVE_MREMAP 1 + +#define _G_IO_IO_FILE_VERSION 0x20001 + +/* This is defined by if `st_blksize' exists. */ +#define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE) + +#define _G_BUFSIZ 8192 + +#endif /* _G_config.h */ diff --git a/libktorrent/miniboost/alloca.h b/libktorrent/miniboost/alloca.h new file mode 100644 index 00000000..2d592d4f --- /dev/null +++ b/libktorrent/miniboost/alloca.h @@ -0,0 +1,40 @@ +/* Copyright (C) 1992-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _ALLOCA_H +#define _ALLOCA_H 1 + +#include + +#define __need_size_t +#include + +__BEGIN_DECLS + +/* Remove any previous definitions. */ +#undef alloca + +/* Allocate a block that will be freed when the calling function exits. */ +extern void *alloca (size_t __size) __THROW; + +#ifdef __GNUC__ +# define alloca(size) __builtin_alloca (size) +#endif /* GCC. */ + +__END_DECLS + +#endif /* alloca.h */ diff --git a/libktorrent/miniboost/asm-generic/errno-base.h b/libktorrent/miniboost/asm-generic/errno-base.h new file mode 100644 index 00000000..65115978 --- /dev/null +++ b/libktorrent/miniboost/asm-generic/errno-base.h @@ -0,0 +1,39 @@ +#ifndef _ASM_GENERIC_ERRNO_BASE_H +#define _ASM_GENERIC_ERRNO_BASE_H + +#define EPERM 1 /* Operation not permitted */ +#define ENOENT 2 /* No such file or directory */ +#define ESRCH 3 /* No such process */ +#define EINTR 4 /* Interrupted system call */ +#define EIO 5 /* I/O error */ +#define ENXIO 6 /* No such device or address */ +#define E2BIG 7 /* Argument list too long */ +#define ENOEXEC 8 /* Exec format error */ +#define EBADF 9 /* Bad file number */ +#define ECHILD 10 /* No child processes */ +#define EAGAIN 11 /* Try again */ +#define ENOMEM 12 /* Out of memory */ +#define EACCES 13 /* Permission denied */ +#define EFAULT 14 /* Bad address */ +#define ENOTBLK 15 /* Block device required */ +#define EBUSY 16 /* Device or resource busy */ +#define EEXIST 17 /* File exists */ +#define EXDEV 18 /* Cross-device link */ +#define ENODEV 19 /* No such device */ +#define ENOTDIR 20 /* Not a directory */ +#define EISDIR 21 /* Is a directory */ +#define EINVAL 22 /* Invalid argument */ +#define ENFILE 23 /* File table overflow */ +#define EMFILE 24 /* Too many open files */ +#define ENOTTY 25 /* Not a typewriter */ +#define ETXTBSY 26 /* Text file busy */ +#define EFBIG 27 /* File too large */ +#define ENOSPC 28 /* No space left on device */ +#define ESPIPE 29 /* Illegal seek */ +#define EROFS 30 /* Read-only file system */ +#define EMLINK 31 /* Too many links */ +#define EPIPE 32 /* Broken pipe */ +#define EDOM 33 /* Math argument out of domain of func */ +#define ERANGE 34 /* Math result not representable */ + +#endif diff --git a/libktorrent/miniboost/asm-generic/errno.h b/libktorrent/miniboost/asm-generic/errno.h new file mode 100644 index 00000000..1e1ea6e6 --- /dev/null +++ b/libktorrent/miniboost/asm-generic/errno.h @@ -0,0 +1,113 @@ +#ifndef _ASM_GENERIC_ERRNO_H +#define _ASM_GENERIC_ERRNO_H + +#include + +#define EDEADLK 35 /* Resource deadlock would occur */ +#define ENAMETOOLONG 36 /* File name too long */ +#define ENOLCK 37 /* No record locks available */ +#define ENOSYS 38 /* Function not implemented */ +#define ENOTEMPTY 39 /* Directory not empty */ +#define ELOOP 40 /* Too many symbolic links encountered */ +#define EWOULDBLOCK EAGAIN /* Operation would block */ +#define ENOMSG 42 /* No message of desired type */ +#define EIDRM 43 /* Identifier removed */ +#define ECHRNG 44 /* Channel number out of range */ +#define EL2NSYNC 45 /* Level 2 not synchronized */ +#define EL3HLT 46 /* Level 3 halted */ +#define EL3RST 47 /* Level 3 reset */ +#define ELNRNG 48 /* Link number out of range */ +#define EUNATCH 49 /* Protocol driver not attached */ +#define ENOCSI 50 /* No CSI structure available */ +#define EL2HLT 51 /* Level 2 halted */ +#define EBADE 52 /* Invalid exchange */ +#define EBADR 53 /* Invalid request descriptor */ +#define EXFULL 54 /* Exchange full */ +#define ENOANO 55 /* No anode */ +#define EBADRQC 56 /* Invalid request code */ +#define EBADSLT 57 /* Invalid slot */ + +#define EDEADLOCK EDEADLK + +#define EBFONT 59 /* Bad font file format */ +#define ENOSTR 60 /* Device not a stream */ +#define ENODATA 61 /* No data available */ +#define ETIME 62 /* Timer expired */ +#define ENOSR 63 /* Out of streams resources */ +#define ENONET 64 /* Machine is not on the network */ +#define ENOPKG 65 /* Package not installed */ +#define EREMOTE 66 /* Object is remote */ +#define ENOLINK 67 /* Link has been severed */ +#define EADV 68 /* Advertise error */ +#define ESRMNT 69 /* Srmount error */ +#define ECOMM 70 /* Communication error on send */ +#define EPROTO 71 /* Protocol error */ +#define EMULTIHOP 72 /* Multihop attempted */ +#define EDOTDOT 73 /* RFS specific error */ +#define EBADMSG 74 /* Not a data message */ +#define EOVERFLOW 75 /* Value too large for defined data type */ +#define ENOTUNIQ 76 /* Name not unique on network */ +#define EBADFD 77 /* File descriptor in bad state */ +#define EREMCHG 78 /* Remote address changed */ +#define ELIBACC 79 /* Can not access a needed shared library */ +#define ELIBBAD 80 /* Accessing a corrupted shared library */ +#define ELIBSCN 81 /* .lib section in a.out corrupted */ +#define ELIBMAX 82 /* Attempting to link in too many shared libraries */ +#define ELIBEXEC 83 /* Cannot exec a shared library directly */ +#define EILSEQ 84 /* Illegal byte sequence */ +#define ERESTART 85 /* Interrupted system call should be restarted */ +#define ESTRPIPE 86 /* Streams pipe error */ +#define EUSERS 87 /* Too many users */ +#define ENOTSOCK 88 /* Socket operation on non-socket */ +#define EDESTADDRREQ 89 /* Destination address required */ +#define EMSGSIZE 90 /* Message too long */ +#define EPROTOTYPE 91 /* Protocol wrong type for socket */ +#define ENOPROTOOPT 92 /* Protocol not available */ +#define EPROTONOSUPPORT 93 /* Protocol not supported */ +#define ESOCKTNOSUPPORT 94 /* Socket type not supported */ +#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */ +#define EPFNOSUPPORT 96 /* Protocol family not supported */ +#define EAFNOSUPPORT 97 /* Address family not supported by protocol */ +#define EADDRINUSE 98 /* Address already in use */ +#define EADDRNOTAVAIL 99 /* Cannot assign requested address */ +#define ENETDOWN 100 /* Network is down */ +#define ENETUNREACH 101 /* Network is unreachable */ +#define ENETRESET 102 /* Network dropped connection because of reset */ +#define ECONNABORTED 103 /* Software caused connection abort */ +#define ECONNRESET 104 /* Connection reset by peer */ +#define ENOBUFS 105 /* No buffer space available */ +#define EISCONN 106 /* Transport endpoint is already connected */ +#define ENOTCONN 107 /* Transport endpoint is not connected */ +#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */ +#define ETOOMANYREFS 109 /* Too many references: cannot splice */ +#define ETIMEDOUT 110 /* Connection timed out */ +#define ECONNREFUSED 111 /* Connection refused */ +#define EHOSTDOWN 112 /* Host is down */ +#define EHOSTUNREACH 113 /* No route to host */ +#define EALREADY 114 /* Operation already in progress */ +#define EINPROGRESS 115 /* Operation now in progress */ +#define ESTALE 116 /* Stale file handle */ +#define EUCLEAN 117 /* Structure needs cleaning */ +#define ENOTNAM 118 /* Not a XENIX named type file */ +#define ENAVAIL 119 /* No XENIX semaphores available */ +#define EISNAM 120 /* Is a named type file */ +#define EREMOTEIO 121 /* Remote I/O error */ +#define EDQUOT 122 /* Quota exceeded */ + +#define ENOMEDIUM 123 /* No medium found */ +#define EMEDIUMTYPE 124 /* Wrong medium type */ +#define ECANCELED 125 /* Operation Canceled */ +#define ENOKEY 126 /* Required key not available */ +#define EKEYEXPIRED 127 /* Key has expired */ +#define EKEYREVOKED 128 /* Key has been revoked */ +#define EKEYREJECTED 129 /* Key was rejected by service */ + +/* for robust mutexes */ +#define EOWNERDEAD 130 /* Owner died */ +#define ENOTRECOVERABLE 131 /* State not recoverable */ + +#define ERFKILL 132 /* Operation not possible due to RF-kill */ + +#define EHWPOISON 133 /* Memory page has hardware error */ + +#endif diff --git a/libktorrent/miniboost/asm-generic/param.h b/libktorrent/miniboost/asm-generic/param.h new file mode 100644 index 00000000..bd69ff3f --- /dev/null +++ b/libktorrent/miniboost/asm-generic/param.h @@ -0,0 +1,19 @@ +#ifndef __ASM_GENERIC_PARAM_H +#define __ASM_GENERIC_PARAM_H + +#ifndef HZ +#define HZ 100 +#endif + +#ifndef EXEC_PAGESIZE +#define EXEC_PAGESIZE 4096 +#endif + +#ifndef NOGROUP +#define NOGROUP (-1) +#endif + +#define MAXHOSTNAMELEN 64 /* max length of hostname */ + + +#endif /* __ASM_GENERIC_PARAM_H */ diff --git a/libktorrent/miniboost/asm/errno.h b/libktorrent/miniboost/asm/errno.h new file mode 100644 index 00000000..4c82b503 --- /dev/null +++ b/libktorrent/miniboost/asm/errno.h @@ -0,0 +1 @@ +#include diff --git a/libktorrent/miniboost/asm/param.h b/libktorrent/miniboost/asm/param.h new file mode 100644 index 00000000..965d4542 --- /dev/null +++ b/libktorrent/miniboost/asm/param.h @@ -0,0 +1 @@ +#include diff --git a/libktorrent/miniboost/assert.h b/libktorrent/miniboost/assert.h new file mode 100644 index 00000000..26613919 --- /dev/null +++ b/libktorrent/miniboost/assert.h @@ -0,0 +1,119 @@ +/* Copyright (C) 1991-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* + * ISO C99 Standard: 7.2 Diagnostics + */ + +#ifdef _ASSERT_H + +# undef _ASSERT_H +# undef assert +# undef __ASSERT_VOID_CAST + +# ifdef __USE_GNU +# undef assert_perror +# endif + +#endif /* assert.h */ + +#define _ASSERT_H 1 +#include + +#if defined __cplusplus && __GNUC_PREREQ (2,95) +# define __ASSERT_VOID_CAST static_cast +#else +# define __ASSERT_VOID_CAST (void) +#endif + +/* void assert (int expression); + + If NDEBUG is defined, do nothing. + If not, and EXPRESSION is zero, print an error message and abort. */ + +#ifdef NDEBUG + +# define assert(expr) (__ASSERT_VOID_CAST (0)) + +/* void assert_perror (int errnum); + + If NDEBUG is defined, do nothing. If not, and ERRNUM is not zero, print an + error message with the error text for ERRNUM and abort. + (This is a GNU extension.) */ + +# ifdef __USE_GNU +# define assert_perror(errnum) (__ASSERT_VOID_CAST (0)) +# endif + +#else /* Not NDEBUG. */ + +__BEGIN_DECLS + +/* This prints an "Assertion failed" message and aborts. */ +extern void __assert_fail (const char *__assertion, const char *__file, + unsigned int __line, const char *__function) + __THROW __attribute__ ((__noreturn__)); + +/* Likewise, but prints the error text for ERRNUM. */ +extern void __assert_perror_fail (int __errnum, const char *__file, + unsigned int __line, const char *__function) + __THROW __attribute__ ((__noreturn__)); + + +/* The following is not at all used here but needed for standard + compliance. */ +extern void __assert (const char *__assertion, const char *__file, int __line) + __THROW __attribute__ ((__noreturn__)); + + +__END_DECLS + +# define assert(expr) \ + ((expr) \ + ? __ASSERT_VOID_CAST (0) \ + : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION)) + +# ifdef __USE_GNU +# define assert_perror(errnum) \ + (!(errnum) \ + ? __ASSERT_VOID_CAST (0) \ + : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION)) +# endif + +/* Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__' + which contains the name of the function currently being defined. + This is broken in G++ before version 2.6. + C9x has a similar variable called __func__, but prefer the GCC one since + it demangles C++ function names. */ +# if defined __cplusplus ? __GNUC_PREREQ (2, 6) : __GNUC_PREREQ (2, 4) +# define __ASSERT_FUNCTION __PRETTY_FUNCTION__ +# else +# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L +# define __ASSERT_FUNCTION __func__ +# else +# define __ASSERT_FUNCTION ((const char *) 0) +# endif +# endif + +#endif /* NDEBUG. */ + + +#if defined __USE_ISOC11 && !defined __cplusplus +/* Static assertion. Requires support in the compiler. */ +# undef static_assert +# define static_assert _Static_assert +#endif diff --git a/libktorrent/miniboost/bits/byteswap-16.h b/libktorrent/miniboost/bits/byteswap-16.h new file mode 100644 index 00000000..f3a9c6b2 --- /dev/null +++ b/libktorrent/miniboost/bits/byteswap-16.h @@ -0,0 +1,49 @@ +/* Macros to swap the order of bytes in 16-bit integer values. + Copyright (C) 2012-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_BYTESWAP_H +# error "Never use directly; include instead." +#endif + +#ifdef __GNUC__ +# if __GNUC__ >= 2 +# define __bswap_16(x) \ + (__extension__ \ + ({ unsigned short int __v, __x = (unsigned short int) (x); \ + if (__builtin_constant_p (__x)) \ + __v = __bswap_constant_16 (__x); \ + else \ + __asm__ ("rorw $8, %w0" \ + : "=r" (__v) \ + : "0" (__x) \ + : "cc"); \ + __v; })) +# else +/* This is better than nothing. */ +# define __bswap_16(x) \ + (__extension__ \ + ({ unsigned short int __x = (unsigned short int) (x); \ + __bswap_constant_16 (__x); })) +# endif +#else +static __inline unsigned short int +__bswap_16 (unsigned short int __bsx) +{ + return __bswap_constant_16 (__bsx); +} +#endif diff --git a/libktorrent/miniboost/bits/byteswap.h b/libktorrent/miniboost/bits/byteswap.h new file mode 100644 index 00000000..933fe4be --- /dev/null +++ b/libktorrent/miniboost/bits/byteswap.h @@ -0,0 +1,155 @@ +/* Macros to swap the order of bytes in integer values. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#if !defined _BYTESWAP_H && !defined _NETINET_IN_H && !defined _ENDIAN_H +# error "Never use directly; include instead." +#endif + +#ifndef _BITS_BYTESWAP_H +#define _BITS_BYTESWAP_H 1 + +#include +#include +#include + +/* Swap bytes in 16 bit value. */ +#define __bswap_constant_16(x) \ + ((unsigned short int) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))) + +/* Get __bswap_16. */ +#include + +/* Swap bytes in 32 bit value. */ +#define __bswap_constant_32(x) \ + ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) + +#ifdef __GNUC__ +# if __GNUC_PREREQ (4, 3) +static __inline unsigned int +__bswap_32 (unsigned int __bsx) +{ + return __builtin_bswap32 (__bsx); +} +# elif __GNUC__ >= 2 +# if __WORDSIZE == 64 || (defined __i486__ || defined __pentium__ \ + || defined __pentiumpro__ || defined __pentium4__ \ + || defined __k8__ || defined __athlon__ \ + || defined __k6__ || defined __nocona__ \ + || defined __core2__ || defined __geode__ \ + || defined __amdfam10__) +/* To swap the bytes in a word the i486 processors and up provide the + `bswap' opcode. On i386 we have to use three instructions. */ +# define __bswap_32(x) \ + (__extension__ \ + ({ unsigned int __v, __x = (x); \ + if (__builtin_constant_p (__x)) \ + __v = __bswap_constant_32 (__x); \ + else \ + __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); \ + __v; })) +# else +# define __bswap_32(x) \ + (__extension__ \ + ({ unsigned int __v, __x = (x); \ + if (__builtin_constant_p (__x)) \ + __v = __bswap_constant_32 (__x); \ + else \ + __asm__ ("rorw $8, %w0;" \ + "rorl $16, %0;" \ + "rorw $8, %w0" \ + : "=r" (__v) \ + : "0" (__x) \ + : "cc"); \ + __v; })) +# endif +# else +# define __bswap_32(x) \ + (__extension__ \ + ({ unsigned int __x = (x); __bswap_constant_32 (__x); })) +# endif +#else +static __inline unsigned int +__bswap_32 (unsigned int __bsx) +{ + return __bswap_constant_32 (__bsx); +} +#endif + + +#if __GNUC_PREREQ (2, 0) +/* Swap bytes in 64 bit value. */ +# define __bswap_constant_64(x) \ + (__extension__ ((((x) & 0xff00000000000000ull) >> 56) \ + | (((x) & 0x00ff000000000000ull) >> 40) \ + | (((x) & 0x0000ff0000000000ull) >> 24) \ + | (((x) & 0x000000ff00000000ull) >> 8) \ + | (((x) & 0x00000000ff000000ull) << 8) \ + | (((x) & 0x0000000000ff0000ull) << 24) \ + | (((x) & 0x000000000000ff00ull) << 40) \ + | (((x) & 0x00000000000000ffull) << 56))) + +# if __GNUC_PREREQ (4, 3) +static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + return __builtin_bswap64 (__bsx); +} +# elif __WORDSIZE == 64 +# define __bswap_64(x) \ + (__extension__ \ + ({ __uint64_t __v, __x = (x); \ + if (__builtin_constant_p (__x)) \ + __v = __bswap_constant_64 (__x); \ + else \ + __asm__ ("bswap %q0" : "=r" (__v) : "0" (__x)); \ + __v; })) +# else +# define __bswap_64(x) \ + (__extension__ \ + ({ union { __extension__ __uint64_t __ll; \ + unsigned int __l[2]; } __w, __r; \ + if (__builtin_constant_p (x)) \ + __r.__ll = __bswap_constant_64 (x); \ + else \ + { \ + __w.__ll = (x); \ + __r.__l[0] = __bswap_32 (__w.__l[1]); \ + __r.__l[1] = __bswap_32 (__w.__l[0]); \ + } \ + __r.__ll; })) +# endif +#else +# define __bswap_constant_64(x) \ + ((((x) & 0xff00000000000000ull) >> 56) \ + | (((x) & 0x00ff000000000000ull) >> 40) \ + | (((x) & 0x0000ff0000000000ull) >> 24) \ + | (((x) & 0x000000ff00000000ull) >> 8) \ + | (((x) & 0x00000000ff000000ull) << 8) \ + | (((x) & 0x0000000000ff0000ull) << 24) \ + | (((x) & 0x000000000000ff00ull) << 40) \ + | (((x) & 0x00000000000000ffull) << 56)) + +static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + return __bswap_constant_64 (__bsx); +} +#endif + +#endif /* _BITS_BYTESWAP_H */ diff --git a/libktorrent/miniboost/bits/confname.h b/libktorrent/miniboost/bits/confname.h new file mode 100644 index 00000000..bf2fcc53 --- /dev/null +++ b/libktorrent/miniboost/bits/confname.h @@ -0,0 +1,675 @@ +/* `sysconf', `pathconf', and `confstr' NAME values. Generic version. + Copyright (C) 1993-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _UNISTD_H +# error "Never use directly; include instead." +#endif + +/* Values for the NAME argument to `pathconf' and `fpathconf'. */ +enum + { + _PC_LINK_MAX, +#define _PC_LINK_MAX _PC_LINK_MAX + _PC_MAX_CANON, +#define _PC_MAX_CANON _PC_MAX_CANON + _PC_MAX_INPUT, +#define _PC_MAX_INPUT _PC_MAX_INPUT + _PC_NAME_MAX, +#define _PC_NAME_MAX _PC_NAME_MAX + _PC_PATH_MAX, +#define _PC_PATH_MAX _PC_PATH_MAX + _PC_PIPE_BUF, +#define _PC_PIPE_BUF _PC_PIPE_BUF + _PC_CHOWN_RESTRICTED, +#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED + _PC_NO_TRUNC, +#define _PC_NO_TRUNC _PC_NO_TRUNC + _PC_VDISABLE, +#define _PC_VDISABLE _PC_VDISABLE + _PC_SYNC_IO, +#define _PC_SYNC_IO _PC_SYNC_IO + _PC_ASYNC_IO, +#define _PC_ASYNC_IO _PC_ASYNC_IO + _PC_PRIO_IO, +#define _PC_PRIO_IO _PC_PRIO_IO + _PC_SOCK_MAXBUF, +#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF + _PC_FILESIZEBITS, +#define _PC_FILESIZEBITS _PC_FILESIZEBITS + _PC_REC_INCR_XFER_SIZE, +#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE + _PC_REC_MAX_XFER_SIZE, +#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE + _PC_REC_MIN_XFER_SIZE, +#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE + _PC_REC_XFER_ALIGN, +#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN + _PC_ALLOC_SIZE_MIN, +#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN + _PC_SYMLINK_MAX, +#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX + _PC_2_SYMLINKS +#define _PC_2_SYMLINKS _PC_2_SYMLINKS + }; + +/* Values for the argument to `sysconf'. */ +enum + { + _SC_ARG_MAX, +#define _SC_ARG_MAX _SC_ARG_MAX + _SC_CHILD_MAX, +#define _SC_CHILD_MAX _SC_CHILD_MAX + _SC_CLK_TCK, +#define _SC_CLK_TCK _SC_CLK_TCK + _SC_NGROUPS_MAX, +#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX + _SC_OPEN_MAX, +#define _SC_OPEN_MAX _SC_OPEN_MAX + _SC_STREAM_MAX, +#define _SC_STREAM_MAX _SC_STREAM_MAX + _SC_TZNAME_MAX, +#define _SC_TZNAME_MAX _SC_TZNAME_MAX + _SC_JOB_CONTROL, +#define _SC_JOB_CONTROL _SC_JOB_CONTROL + _SC_SAVED_IDS, +#define _SC_SAVED_IDS _SC_SAVED_IDS + _SC_REALTIME_SIGNALS, +#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS + _SC_PRIORITY_SCHEDULING, +#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING + _SC_TIMERS, +#define _SC_TIMERS _SC_TIMERS + _SC_ASYNCHRONOUS_IO, +#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO + _SC_PRIORITIZED_IO, +#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO + _SC_SYNCHRONIZED_IO, +#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO + _SC_FSYNC, +#define _SC_FSYNC _SC_FSYNC + _SC_MAPPED_FILES, +#define _SC_MAPPED_FILES _SC_MAPPED_FILES + _SC_MEMLOCK, +#define _SC_MEMLOCK _SC_MEMLOCK + _SC_MEMLOCK_RANGE, +#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE + _SC_MEMORY_PROTECTION, +#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION + _SC_MESSAGE_PASSING, +#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING + _SC_SEMAPHORES, +#define _SC_SEMAPHORES _SC_SEMAPHORES + _SC_SHARED_MEMORY_OBJECTS, +#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS + _SC_AIO_LISTIO_MAX, +#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX + _SC_AIO_MAX, +#define _SC_AIO_MAX _SC_AIO_MAX + _SC_AIO_PRIO_DELTA_MAX, +#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX + _SC_DELAYTIMER_MAX, +#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX + _SC_MQ_OPEN_MAX, +#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX + _SC_MQ_PRIO_MAX, +#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX + _SC_VERSION, +#define _SC_VERSION _SC_VERSION + _SC_PAGESIZE, +#define _SC_PAGESIZE _SC_PAGESIZE +#define _SC_PAGE_SIZE _SC_PAGESIZE + _SC_RTSIG_MAX, +#define _SC_RTSIG_MAX _SC_RTSIG_MAX + _SC_SEM_NSEMS_MAX, +#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX + _SC_SEM_VALUE_MAX, +#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX + _SC_SIGQUEUE_MAX, +#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX + _SC_TIMER_MAX, +#define _SC_TIMER_MAX _SC_TIMER_MAX + + /* Values for the argument to `sysconf' + corresponding to _POSIX2_* symbols. */ + _SC_BC_BASE_MAX, +#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX + _SC_BC_DIM_MAX, +#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX + _SC_BC_SCALE_MAX, +#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX + _SC_BC_STRING_MAX, +#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX + _SC_COLL_WEIGHTS_MAX, +#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX + _SC_EQUIV_CLASS_MAX, +#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX + _SC_EXPR_NEST_MAX, +#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX + _SC_LINE_MAX, +#define _SC_LINE_MAX _SC_LINE_MAX + _SC_RE_DUP_MAX, +#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX + _SC_CHARCLASS_NAME_MAX, +#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX + + _SC_2_VERSION, +#define _SC_2_VERSION _SC_2_VERSION + _SC_2_C_BIND, +#define _SC_2_C_BIND _SC_2_C_BIND + _SC_2_C_DEV, +#define _SC_2_C_DEV _SC_2_C_DEV + _SC_2_FORT_DEV, +#define _SC_2_FORT_DEV _SC_2_FORT_DEV + _SC_2_FORT_RUN, +#define _SC_2_FORT_RUN _SC_2_FORT_RUN + _SC_2_SW_DEV, +#define _SC_2_SW_DEV _SC_2_SW_DEV + _SC_2_LOCALEDEF, +#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF + + _SC_PII, +#define _SC_PII _SC_PII + _SC_PII_XTI, +#define _SC_PII_XTI _SC_PII_XTI + _SC_PII_SOCKET, +#define _SC_PII_SOCKET _SC_PII_SOCKET + _SC_PII_INTERNET, +#define _SC_PII_INTERNET _SC_PII_INTERNET + _SC_PII_OSI, +#define _SC_PII_OSI _SC_PII_OSI + _SC_POLL, +#define _SC_POLL _SC_POLL + _SC_SELECT, +#define _SC_SELECT _SC_SELECT + _SC_UIO_MAXIOV, +#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV + _SC_IOV_MAX = _SC_UIO_MAXIOV, +#define _SC_IOV_MAX _SC_IOV_MAX + _SC_PII_INTERNET_STREAM, +#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM + _SC_PII_INTERNET_DGRAM, +#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM + _SC_PII_OSI_COTS, +#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS + _SC_PII_OSI_CLTS, +#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS + _SC_PII_OSI_M, +#define _SC_PII_OSI_M _SC_PII_OSI_M + _SC_T_IOV_MAX, +#define _SC_T_IOV_MAX _SC_T_IOV_MAX + + /* Values according to POSIX 1003.1c (POSIX threads). */ + _SC_THREADS, +#define _SC_THREADS _SC_THREADS + _SC_THREAD_SAFE_FUNCTIONS, +#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS + _SC_GETGR_R_SIZE_MAX, +#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX + _SC_GETPW_R_SIZE_MAX, +#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX + _SC_LOGIN_NAME_MAX, +#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX + _SC_TTY_NAME_MAX, +#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX + _SC_THREAD_DESTRUCTOR_ITERATIONS, +#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS + _SC_THREAD_KEYS_MAX, +#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX + _SC_THREAD_STACK_MIN, +#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN + _SC_THREAD_THREADS_MAX, +#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX + _SC_THREAD_ATTR_STACKADDR, +#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR + _SC_THREAD_ATTR_STACKSIZE, +#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE + _SC_THREAD_PRIORITY_SCHEDULING, +#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING + _SC_THREAD_PRIO_INHERIT, +#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT + _SC_THREAD_PRIO_PROTECT, +#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT + _SC_THREAD_PROCESS_SHARED, +#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED + + _SC_NPROCESSORS_CONF, +#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF + _SC_NPROCESSORS_ONLN, +#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN + _SC_PHYS_PAGES, +#define _SC_PHYS_PAGES _SC_PHYS_PAGES + _SC_AVPHYS_PAGES, +#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES + _SC_ATEXIT_MAX, +#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX + _SC_PASS_MAX, +#define _SC_PASS_MAX _SC_PASS_MAX + + _SC_XOPEN_VERSION, +#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION + _SC_XOPEN_XCU_VERSION, +#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION + _SC_XOPEN_UNIX, +#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX + _SC_XOPEN_CRYPT, +#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT + _SC_XOPEN_ENH_I18N, +#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N + _SC_XOPEN_SHM, +#define _SC_XOPEN_SHM _SC_XOPEN_SHM + + _SC_2_CHAR_TERM, +#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM + _SC_2_C_VERSION, +#define _SC_2_C_VERSION _SC_2_C_VERSION + _SC_2_UPE, +#define _SC_2_UPE _SC_2_UPE + + _SC_XOPEN_XPG2, +#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2 + _SC_XOPEN_XPG3, +#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3 + _SC_XOPEN_XPG4, +#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4 + + _SC_CHAR_BIT, +#define _SC_CHAR_BIT _SC_CHAR_BIT + _SC_CHAR_MAX, +#define _SC_CHAR_MAX _SC_CHAR_MAX + _SC_CHAR_MIN, +#define _SC_CHAR_MIN _SC_CHAR_MIN + _SC_INT_MAX, +#define _SC_INT_MAX _SC_INT_MAX + _SC_INT_MIN, +#define _SC_INT_MIN _SC_INT_MIN + _SC_LONG_BIT, +#define _SC_LONG_BIT _SC_LONG_BIT + _SC_WORD_BIT, +#define _SC_WORD_BIT _SC_WORD_BIT + _SC_MB_LEN_MAX, +#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX + _SC_NZERO, +#define _SC_NZERO _SC_NZERO + _SC_SSIZE_MAX, +#define _SC_SSIZE_MAX _SC_SSIZE_MAX + _SC_SCHAR_MAX, +#define _SC_SCHAR_MAX _SC_SCHAR_MAX + _SC_SCHAR_MIN, +#define _SC_SCHAR_MIN _SC_SCHAR_MIN + _SC_SHRT_MAX, +#define _SC_SHRT_MAX _SC_SHRT_MAX + _SC_SHRT_MIN, +#define _SC_SHRT_MIN _SC_SHRT_MIN + _SC_UCHAR_MAX, +#define _SC_UCHAR_MAX _SC_UCHAR_MAX + _SC_UINT_MAX, +#define _SC_UINT_MAX _SC_UINT_MAX + _SC_ULONG_MAX, +#define _SC_ULONG_MAX _SC_ULONG_MAX + _SC_USHRT_MAX, +#define _SC_USHRT_MAX _SC_USHRT_MAX + + _SC_NL_ARGMAX, +#define _SC_NL_ARGMAX _SC_NL_ARGMAX + _SC_NL_LANGMAX, +#define _SC_NL_LANGMAX _SC_NL_LANGMAX + _SC_NL_MSGMAX, +#define _SC_NL_MSGMAX _SC_NL_MSGMAX + _SC_NL_NMAX, +#define _SC_NL_NMAX _SC_NL_NMAX + _SC_NL_SETMAX, +#define _SC_NL_SETMAX _SC_NL_SETMAX + _SC_NL_TEXTMAX, +#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX + + _SC_XBS5_ILP32_OFF32, +#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32 + _SC_XBS5_ILP32_OFFBIG, +#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG + _SC_XBS5_LP64_OFF64, +#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64 + _SC_XBS5_LPBIG_OFFBIG, +#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG + + _SC_XOPEN_LEGACY, +#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY + _SC_XOPEN_REALTIME, +#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME + _SC_XOPEN_REALTIME_THREADS, +#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS + + _SC_ADVISORY_INFO, +#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO + _SC_BARRIERS, +#define _SC_BARRIERS _SC_BARRIERS + _SC_BASE, +#define _SC_BASE _SC_BASE + _SC_C_LANG_SUPPORT, +#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT + _SC_C_LANG_SUPPORT_R, +#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R + _SC_CLOCK_SELECTION, +#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION + _SC_CPUTIME, +#define _SC_CPUTIME _SC_CPUTIME + _SC_THREAD_CPUTIME, +#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME + _SC_DEVICE_IO, +#define _SC_DEVICE_IO _SC_DEVICE_IO + _SC_DEVICE_SPECIFIC, +#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC + _SC_DEVICE_SPECIFIC_R, +#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R + _SC_FD_MGMT, +#define _SC_FD_MGMT _SC_FD_MGMT + _SC_FIFO, +#define _SC_FIFO _SC_FIFO + _SC_PIPE, +#define _SC_PIPE _SC_PIPE + _SC_FILE_ATTRIBUTES, +#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES + _SC_FILE_LOCKING, +#define _SC_FILE_LOCKING _SC_FILE_LOCKING + _SC_FILE_SYSTEM, +#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM + _SC_MONOTONIC_CLOCK, +#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK + _SC_MULTI_PROCESS, +#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS + _SC_SINGLE_PROCESS, +#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS + _SC_NETWORKING, +#define _SC_NETWORKING _SC_NETWORKING + _SC_READER_WRITER_LOCKS, +#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS + _SC_SPIN_LOCKS, +#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS + _SC_REGEXP, +#define _SC_REGEXP _SC_REGEXP + _SC_REGEX_VERSION, +#define _SC_REGEX_VERSION _SC_REGEX_VERSION + _SC_SHELL, +#define _SC_SHELL _SC_SHELL + _SC_SIGNALS, +#define _SC_SIGNALS _SC_SIGNALS + _SC_SPAWN, +#define _SC_SPAWN _SC_SPAWN + _SC_SPORADIC_SERVER, +#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER + _SC_THREAD_SPORADIC_SERVER, +#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER + _SC_SYSTEM_DATABASE, +#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE + _SC_SYSTEM_DATABASE_R, +#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R + _SC_TIMEOUTS, +#define _SC_TIMEOUTS _SC_TIMEOUTS + _SC_TYPED_MEMORY_OBJECTS, +#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS + _SC_USER_GROUPS, +#define _SC_USER_GROUPS _SC_USER_GROUPS + _SC_USER_GROUPS_R, +#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R + _SC_2_PBS, +#define _SC_2_PBS _SC_2_PBS + _SC_2_PBS_ACCOUNTING, +#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING + _SC_2_PBS_LOCATE, +#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE + _SC_2_PBS_MESSAGE, +#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE + _SC_2_PBS_TRACK, +#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK + _SC_SYMLOOP_MAX, +#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX + _SC_STREAMS, +#define _SC_STREAMS _SC_STREAMS + _SC_2_PBS_CHECKPOINT, +#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT + + _SC_V6_ILP32_OFF32, +#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32 + _SC_V6_ILP32_OFFBIG, +#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG + _SC_V6_LP64_OFF64, +#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64 + _SC_V6_LPBIG_OFFBIG, +#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG + + _SC_HOST_NAME_MAX, +#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX + _SC_TRACE, +#define _SC_TRACE _SC_TRACE + _SC_TRACE_EVENT_FILTER, +#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER + _SC_TRACE_INHERIT, +#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT + _SC_TRACE_LOG, +#define _SC_TRACE_LOG _SC_TRACE_LOG + + _SC_LEVEL1_ICACHE_SIZE, +#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE + _SC_LEVEL1_ICACHE_ASSOC, +#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC + _SC_LEVEL1_ICACHE_LINESIZE, +#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE + _SC_LEVEL1_DCACHE_SIZE, +#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE + _SC_LEVEL1_DCACHE_ASSOC, +#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC + _SC_LEVEL1_DCACHE_LINESIZE, +#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE + _SC_LEVEL2_CACHE_SIZE, +#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE + _SC_LEVEL2_CACHE_ASSOC, +#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC + _SC_LEVEL2_CACHE_LINESIZE, +#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE + _SC_LEVEL3_CACHE_SIZE, +#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE + _SC_LEVEL3_CACHE_ASSOC, +#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC + _SC_LEVEL3_CACHE_LINESIZE, +#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE + _SC_LEVEL4_CACHE_SIZE, +#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE + _SC_LEVEL4_CACHE_ASSOC, +#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC + _SC_LEVEL4_CACHE_LINESIZE, +#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE + /* Leave room here, maybe we need a few more cache levels some day. */ + + _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50, +#define _SC_IPV6 _SC_IPV6 + _SC_RAW_SOCKETS, +#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS + + _SC_V7_ILP32_OFF32, +#define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32 + _SC_V7_ILP32_OFFBIG, +#define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG + _SC_V7_LP64_OFF64, +#define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64 + _SC_V7_LPBIG_OFFBIG, +#define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG + + _SC_SS_REPL_MAX, +#define _SC_SS_REPL_MAX _SC_SS_REPL_MAX + + _SC_TRACE_EVENT_NAME_MAX, +#define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX + _SC_TRACE_NAME_MAX, +#define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX + _SC_TRACE_SYS_MAX, +#define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX + _SC_TRACE_USER_EVENT_MAX, +#define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX + + _SC_XOPEN_STREAMS, +#define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS + + _SC_THREAD_ROBUST_PRIO_INHERIT, +#define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT + _SC_THREAD_ROBUST_PRIO_PROTECT +#define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT + }; + +/* Values for the NAME argument to `confstr'. */ +enum + { + _CS_PATH, /* The default search path. */ +#define _CS_PATH _CS_PATH + + _CS_V6_WIDTH_RESTRICTED_ENVS, +#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS +#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS + + _CS_GNU_LIBC_VERSION, +#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION + _CS_GNU_LIBPTHREAD_VERSION, +#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION + + _CS_V5_WIDTH_RESTRICTED_ENVS, +#define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS +#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS + + _CS_V7_WIDTH_RESTRICTED_ENVS, +#define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS +#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS + + _CS_LFS_CFLAGS = 1000, +#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS + _CS_LFS_LDFLAGS, +#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS + _CS_LFS_LIBS, +#define _CS_LFS_LIBS _CS_LFS_LIBS + _CS_LFS_LINTFLAGS, +#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS + _CS_LFS64_CFLAGS, +#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS + _CS_LFS64_LDFLAGS, +#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS + _CS_LFS64_LIBS, +#define _CS_LFS64_LIBS _CS_LFS64_LIBS + _CS_LFS64_LINTFLAGS, +#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS + + _CS_XBS5_ILP32_OFF32_CFLAGS = 1100, +#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS + _CS_XBS5_ILP32_OFF32_LDFLAGS, +#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS + _CS_XBS5_ILP32_OFF32_LIBS, +#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS + _CS_XBS5_ILP32_OFF32_LINTFLAGS, +#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS + _CS_XBS5_ILP32_OFFBIG_CFLAGS, +#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS + _CS_XBS5_ILP32_OFFBIG_LDFLAGS, +#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS + _CS_XBS5_ILP32_OFFBIG_LIBS, +#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS + _CS_XBS5_ILP32_OFFBIG_LINTFLAGS, +#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS + _CS_XBS5_LP64_OFF64_CFLAGS, +#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS + _CS_XBS5_LP64_OFF64_LDFLAGS, +#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS + _CS_XBS5_LP64_OFF64_LIBS, +#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS + _CS_XBS5_LP64_OFF64_LINTFLAGS, +#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS + _CS_XBS5_LPBIG_OFFBIG_CFLAGS, +#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS + _CS_XBS5_LPBIG_OFFBIG_LDFLAGS, +#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS + _CS_XBS5_LPBIG_OFFBIG_LIBS, +#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS + _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS, +#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS + + _CS_POSIX_V6_ILP32_OFF32_CFLAGS, +#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS + _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, +#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS + _CS_POSIX_V6_ILP32_OFF32_LIBS, +#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS + _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS, +#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS + _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS, +#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS + _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, +#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS + _CS_POSIX_V6_ILP32_OFFBIG_LIBS, +#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS + _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS, +#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS + _CS_POSIX_V6_LP64_OFF64_CFLAGS, +#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS + _CS_POSIX_V6_LP64_OFF64_LDFLAGS, +#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS + _CS_POSIX_V6_LP64_OFF64_LIBS, +#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS + _CS_POSIX_V6_LP64_OFF64_LINTFLAGS, +#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS + _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, +#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS + _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, +#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS + _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, +#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS + _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS, +#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS + + _CS_POSIX_V7_ILP32_OFF32_CFLAGS, +#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS + _CS_POSIX_V7_ILP32_OFF32_LDFLAGS, +#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS + _CS_POSIX_V7_ILP32_OFF32_LIBS, +#define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS + _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS, +#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS + _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS, +#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS + _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS, +#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS + _CS_POSIX_V7_ILP32_OFFBIG_LIBS, +#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS + _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS, +#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS + _CS_POSIX_V7_LP64_OFF64_CFLAGS, +#define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS + _CS_POSIX_V7_LP64_OFF64_LDFLAGS, +#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS + _CS_POSIX_V7_LP64_OFF64_LIBS, +#define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS + _CS_POSIX_V7_LP64_OFF64_LINTFLAGS, +#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS + _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS, +#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS + _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS, +#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS + _CS_POSIX_V7_LPBIG_OFFBIG_LIBS, +#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS + _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS, +#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS + + _CS_V6_ENV, +#define _CS_V6_ENV _CS_V6_ENV + _CS_V7_ENV +#define _CS_V7_ENV _CS_V7_ENV + }; diff --git a/libktorrent/miniboost/bits/endian.h b/libktorrent/miniboost/bits/endian.h new file mode 100644 index 00000000..5a56c726 --- /dev/null +++ b/libktorrent/miniboost/bits/endian.h @@ -0,0 +1,7 @@ +/* i386/x86_64 are little-endian. */ + +#ifndef _ENDIAN_H +# error "Never use directly; include instead." +#endif + +#define __BYTE_ORDER __LITTLE_ENDIAN diff --git a/libktorrent/miniboost/bits/environments.h b/libktorrent/miniboost/bits/environments.h new file mode 100644 index 00000000..df40aefd --- /dev/null +++ b/libktorrent/miniboost/bits/environments.h @@ -0,0 +1,105 @@ +/* Copyright (C) 1999-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _UNISTD_H +# error "Never include this file directly. Use instead" +#endif + +#include + +/* This header should define the following symbols under the described + situations. A value `1' means that the model is always supported, + `-1' means it is never supported. Undefined means it cannot be + statically decided. + + _POSIX_V7_ILP32_OFF32 32bit int, long, pointers, and off_t type + _POSIX_V7_ILP32_OFFBIG 32bit int, long, and pointers and larger off_t type + + _POSIX_V7_LP64_OFF32 64bit long and pointers and 32bit off_t type + _POSIX_V7_LPBIG_OFFBIG 64bit long and pointers and large off_t type + + The macros _POSIX_V6_ILP32_OFF32, _POSIX_V6_ILP32_OFFBIG, + _POSIX_V6_LP64_OFF32, _POSIX_V6_LPBIG_OFFBIG, _XBS5_ILP32_OFF32, + _XBS5_ILP32_OFFBIG, _XBS5_LP64_OFF32, and _XBS5_LPBIG_OFFBIG were + used in previous versions of the Unix standard and are available + only for compatibility. +*/ + +#if __WORDSIZE == 64 + +/* Environments with 32-bit wide pointers are optionally provided. + Therefore following macros aren't defined: + # undef _POSIX_V7_ILP32_OFF32 + # undef _POSIX_V7_ILP32_OFFBIG + # undef _POSIX_V6_ILP32_OFF32 + # undef _POSIX_V6_ILP32_OFFBIG + # undef _XBS5_ILP32_OFF32 + # undef _XBS5_ILP32_OFFBIG + and users need to check at runtime. */ + +/* We also have no use (for now) for an environment with bigger pointers + and offsets. */ +# define _POSIX_V7_LPBIG_OFFBIG -1 +# define _POSIX_V6_LPBIG_OFFBIG -1 +# define _XBS5_LPBIG_OFFBIG -1 + +/* By default we have 64-bit wide `long int', pointers and `off_t'. */ +# define _POSIX_V7_LP64_OFF64 1 +# define _POSIX_V6_LP64_OFF64 1 +# define _XBS5_LP64_OFF64 1 + +#else /* __WORDSIZE == 32 */ + +/* We have 32-bit wide `int', `long int' and pointers and all platforms + support LFS. -mx32 has 64-bit wide `off_t'. */ +# define _POSIX_V7_ILP32_OFFBIG 1 +# define _POSIX_V6_ILP32_OFFBIG 1 +# define _XBS5_ILP32_OFFBIG 1 + +# ifndef __x86_64__ +/* -m32 has 32-bit wide `off_t'. */ +# define _POSIX_V7_ILP32_OFF32 1 +# define _POSIX_V6_ILP32_OFF32 1 +# define _XBS5_ILP32_OFF32 1 +# endif + +/* We optionally provide an environment with the above size but an 64-bit + side `off_t'. Therefore we don't define _POSIX_V7_ILP32_OFFBIG. */ + +/* Environments with 64-bit wide pointers can be provided, + so these macros aren't defined: + # undef _POSIX_V7_LP64_OFF64 + # undef _POSIX_V7_LPBIG_OFFBIG + # undef _POSIX_V6_LP64_OFF64 + # undef _POSIX_V6_LPBIG_OFFBIG + # undef _XBS5_LP64_OFF64 + # undef _XBS5_LPBIG_OFFBIG + and sysconf tests for it at runtime. */ + +#endif /* __WORDSIZE == 32 */ + +#define __ILP32_OFF32_CFLAGS "-m32" +#define __ILP32_OFF32_LDFLAGS "-m32" +#if defined __x86_64__ && defined __ILP32__ +# define __ILP32_OFFBIG_CFLAGS "-mx32" +# define __ILP32_OFFBIG_LDFLAGS "-mx32" +#else +# define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64" +# define __ILP32_OFFBIG_LDFLAGS "-m32" +#endif +#define __LP64_OFF64_CFLAGS "-m64" +#define __LP64_OFF64_LDFLAGS "-m64" diff --git a/libktorrent/miniboost/bits/errno.h b/libktorrent/miniboost/bits/errno.h new file mode 100644 index 00000000..e4995b81 --- /dev/null +++ b/libktorrent/miniboost/bits/errno.h @@ -0,0 +1,66 @@ +/* Error constants. Linux specific version. + Copyright (C) 1996-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifdef _ERRNO_H + +# undef EDOM +# undef EILSEQ +# undef ERANGE +# include + +/* Linux has no ENOTSUP error code. */ +# define ENOTSUP EOPNOTSUPP + +/* Older Linux versions also had no ECANCELED error code. */ +# ifndef ECANCELED +# define ECANCELED 125 +# endif + +/* Support for error codes to support robust mutexes was added later, too. */ +# ifndef EOWNERDEAD +# define EOWNERDEAD 130 +# define ENOTRECOVERABLE 131 +# endif + +# ifndef ERFKILL +# define ERFKILL 132 +# endif + +# ifndef EHWPOISON +# define EHWPOISON 133 +# endif + +# ifndef __ASSEMBLER__ +/* Function to get address of global `errno' variable. */ +extern int *__errno_location (void) __THROW __attribute__ ((__const__)); + +# if !defined _LIBC || defined _LIBC_REENTRANT +/* When using threads, errno is a per-thread value. */ +# define errno (*__errno_location ()) +# endif +# endif /* !__ASSEMBLER__ */ +#endif /* _ERRNO_H */ + +#if !defined _ERRNO_H && defined __need_Emath +/* This is ugly but the kernel header is not clean enough. We must + define only the values EDOM, EILSEQ and ERANGE in case __need_Emath is + defined. */ +# define EDOM 33 /* Math argument out of domain of function. */ +# define EILSEQ 84 /* Illegal byte sequence. */ +# define ERANGE 34 /* Math result not representable. */ +#endif /* !_ERRNO_H && __need_Emath */ diff --git a/libktorrent/miniboost/bits/libc-lock.h b/libktorrent/miniboost/bits/libc-lock.h new file mode 100644 index 00000000..532cf2c7 --- /dev/null +++ b/libktorrent/miniboost/bits/libc-lock.h @@ -0,0 +1,187 @@ +/* libc-internal interface for mutex locks. NPTL version. + Copyright (C) 1996-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; see the file COPYING.LIB. If + not, see . */ + +#ifndef _BITS_LIBC_LOCK_H +#define _BITS_LIBC_LOCK_H 1 + +#include +#define __need_NULL +#include + + +/* Mutex type. */ +#if defined _LIBC || defined _IO_MTSAFE_IO +# if (defined NOT_IN_libc && !defined IS_IN_libpthread) || !defined _LIBC +typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t; +# else +typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t; +# endif +#else +typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; +#endif + +/* Define a lock variable NAME with storage class CLASS. The lock must be + initialized with __libc_lock_init before it can be used (or define it + with __libc_lock_define_initialized, below). Use `extern' for CLASS to + declare a lock defined in another module. In public structure + definitions you must use a pointer to the lock structure (i.e., NAME + begins with a `*'), because its storage size will not be known outside + of libc. */ +#define __libc_lock_define_recursive(CLASS,NAME) \ + CLASS __libc_lock_recursive_t NAME; + +/* Define an initialized recursive lock variable NAME with storage + class CLASS. */ +#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) +# define __libc_lock_define_initialized_recursive(CLASS, NAME) \ + CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER; +# define _LIBC_LOCK_RECURSIVE_INITIALIZER \ + { LLL_LOCK_INITIALIZER, 0, NULL } +#else +# define __libc_lock_define_initialized_recursive(CLASS,NAME) \ + CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER; +# define _LIBC_LOCK_RECURSIVE_INITIALIZER \ + {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP} +#endif + +/* Initialize a recursive mutex. */ +#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) +# define __libc_lock_init_recursive(NAME) \ + ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0) +#else +# define __libc_lock_init_recursive(NAME) \ + do { \ + if (__pthread_mutex_init != NULL) \ + { \ + pthread_mutexattr_t __attr; \ + __pthread_mutexattr_init (&__attr); \ + __pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \ + __pthread_mutex_init (&(NAME).mutex, &__attr); \ + __pthread_mutexattr_destroy (&__attr); \ + } \ + } while (0) +#endif + +/* Finalize recursive named lock. */ +#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) +# define __libc_lock_fini_recursive(NAME) ((void) 0) +#else +# define __libc_lock_fini_recursive(NAME) \ + __libc_maybe_call (__pthread_mutex_destroy, (&(NAME).mutex), 0) +#endif + +/* Lock the recursive named lock variable. */ +#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) +# define __libc_lock_lock_recursive(NAME) \ + do { \ + void *self = THREAD_SELF; \ + if ((NAME).owner != self) \ + { \ + lll_lock ((NAME).lock, LLL_PRIVATE); \ + (NAME).owner = self; \ + } \ + ++(NAME).cnt; \ + } while (0) +#else +# define __libc_lock_lock_recursive(NAME) \ + __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0) +#endif + +/* Try to lock the recursive named lock variable. */ +#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) +# define __libc_lock_trylock_recursive(NAME) \ + ({ \ + int result = 0; \ + void *self = THREAD_SELF; \ + if ((NAME).owner != self) \ + { \ + if (lll_trylock ((NAME).lock) == 0) \ + { \ + (NAME).owner = self; \ + (NAME).cnt = 1; \ + } \ + else \ + result = EBUSY; \ + } \ + else \ + ++(NAME).cnt; \ + result; \ + }) +#else +# define __libc_lock_trylock_recursive(NAME) \ + __libc_maybe_call (__pthread_mutex_trylock, (&(NAME).mutex), 0) +#endif + +/* Unlock the recursive named lock variable. */ +#if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) +/* We do no error checking here. */ +# define __libc_lock_unlock_recursive(NAME) \ + do { \ + if (--(NAME).cnt == 0) \ + { \ + (NAME).owner = NULL; \ + lll_unlock ((NAME).lock, LLL_PRIVATE); \ + } \ + } while (0) +#else +# define __libc_lock_unlock_recursive(NAME) \ + __libc_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 0) +#endif + +/* Note that for I/O cleanup handling we are using the old-style + cancel handling. It does not have to be integrated with C++ since + no C++ code is called in the middle. The old-style handling is + faster and the support is not going away. */ +extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, + void (*routine) (void *), void *arg); +extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, + int execute); + +/* Start critical region with cleanup. */ +#define __libc_cleanup_region_start(DOIT, FCT, ARG) \ + { struct _pthread_cleanup_buffer _buffer; \ + int _avail; \ + if (DOIT) { \ + _avail = PTFAVAIL (_pthread_cleanup_push_defer); \ + if (_avail) { \ + __libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT, \ + ARG)); \ + } else { \ + _buffer.__routine = (FCT); \ + _buffer.__arg = (ARG); \ + } \ + } else { \ + _avail = 0; \ + } + +/* End critical region with cleanup. */ +#define __libc_cleanup_region_end(DOIT) \ + if (_avail) { \ + __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\ + } else if (DOIT) \ + _buffer.__routine (_buffer.__arg); \ + } + + +/* Hide the definitions which are only supposed to be used inside libc in + a separate file. This file is not present in the installation! */ +#ifdef _LIBC +# include "libc-lockP.h" +#endif + +#endif /* bits/libc-lock.h */ diff --git a/libktorrent/miniboost/bits/libio-ldbl.h b/libktorrent/miniboost/bits/libio-ldbl.h new file mode 100644 index 00000000..cb08f3d1 --- /dev/null +++ b/libktorrent/miniboost/bits/libio-ldbl.h @@ -0,0 +1,24 @@ +/* -mlong-double-64 compatibility mode for libio functions. + Copyright (C) 2006-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _IO_STDIO_H +# error "Never include directly; use instead." +#endif + +__LDBL_REDIR_DECL (_IO_vfscanf) +__LDBL_REDIR_DECL (_IO_vfprintf) diff --git a/libktorrent/miniboost/bits/local_lim.h b/libktorrent/miniboost/bits/local_lim.h new file mode 100644 index 00000000..b802facd --- /dev/null +++ b/libktorrent/miniboost/bits/local_lim.h @@ -0,0 +1,99 @@ +/* Minimum guaranteed maximum values for system limits. Linux version. + Copyright (C) 1993-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; see the file COPYING.LIB. If + not, see . */ + +/* The kernel header pollutes the namespace with the NR_OPEN symbol + and defines LINK_MAX although filesystems have different maxima. A + similar thing is true for OPEN_MAX: the limit can be changed at + runtime and therefore the macro must not be defined. Remove this + after including the header if necessary. */ +#ifndef NR_OPEN +# define __undef_NR_OPEN +#endif +#ifndef LINK_MAX +# define __undef_LINK_MAX +#endif +#ifndef OPEN_MAX +# define __undef_OPEN_MAX +#endif +#ifndef ARG_MAX +# define __undef_ARG_MAX +#endif + +/* The kernel sources contain a file with all the needed information. */ +#include + +/* Have to remove NR_OPEN? */ +#ifdef __undef_NR_OPEN +# undef NR_OPEN +# undef __undef_NR_OPEN +#endif +/* Have to remove LINK_MAX? */ +#ifdef __undef_LINK_MAX +# undef LINK_MAX +# undef __undef_LINK_MAX +#endif +/* Have to remove OPEN_MAX? */ +#ifdef __undef_OPEN_MAX +# undef OPEN_MAX +# undef __undef_OPEN_MAX +#endif +/* Have to remove ARG_MAX? */ +#ifdef __undef_ARG_MAX +# undef ARG_MAX +# undef __undef_ARG_MAX +#endif + +/* The number of data keys per process. */ +#define _POSIX_THREAD_KEYS_MAX 128 +/* This is the value this implementation supports. */ +#define PTHREAD_KEYS_MAX 1024 + +/* Controlling the iterations of destructors for thread-specific data. */ +#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 +/* Number of iterations this implementation does. */ +#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS + +/* The number of threads per process. */ +#define _POSIX_THREAD_THREADS_MAX 64 +/* We have no predefined limit on the number of threads. */ +#undef PTHREAD_THREADS_MAX + +/* Maximum amount by which a process can descrease its asynchronous I/O + priority level. */ +#define AIO_PRIO_DELTA_MAX 20 + +/* Minimum size for a thread. We are free to choose a reasonable value. */ +#define PTHREAD_STACK_MIN 16384 + +/* Maximum number of timer expiration overruns. */ +#define DELAYTIMER_MAX 2147483647 + +/* Maximum tty name length. */ +#define TTY_NAME_MAX 32 + +/* Maximum login name length. This is arbitrary. */ +#define LOGIN_NAME_MAX 256 + +/* Maximum host name length. */ +#define HOST_NAME_MAX 64 + +/* Maximum message queue priority level. */ +#define MQ_PRIO_MAX 32768 + +/* Maximum value the semaphore can have. */ +#define SEM_VALUE_MAX (2147483647) diff --git a/libktorrent/miniboost/bits/param.h b/libktorrent/miniboost/bits/param.h new file mode 100644 index 00000000..01598f52 --- /dev/null +++ b/libktorrent/miniboost/bits/param.h @@ -0,0 +1,42 @@ +/* Old-style Unix parameters and limits. Linux version. + Copyright (C) 1995-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SYS_PARAM_H +# error "Never use directly; include instead." +#endif + +#ifndef ARG_MAX +# define __undef_ARG_MAX +#endif + +#include +#include + +/* The kernel headers define ARG_MAX. The value is wrong, though. */ +#ifdef __undef_ARG_MAX +# undef ARG_MAX +# undef __undef_ARG_MAX +#endif + +#define MAXSYMLINKS 20 + +/* The following are not really correct but it is a value we used for a + long time and which seems to be usable. People should not use NOFILE + and NCARGS anyway. */ +#define NOFILE 256 +#define NCARGS 131072 diff --git a/libktorrent/miniboost/bits/posix1_lim.h b/libktorrent/miniboost/bits/posix1_lim.h new file mode 100644 index 00000000..97f018d0 --- /dev/null +++ b/libktorrent/miniboost/bits/posix1_lim.h @@ -0,0 +1,175 @@ +/* Copyright (C) 1991-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* + * POSIX Standard: 2.9.2 Minimum Values Added to + * + * Never include this file directly; use instead. + */ + +#ifndef _BITS_POSIX1_LIM_H +#define _BITS_POSIX1_LIM_H 1 + + +/* These are the standard-mandated minimum values. */ + +/* Minimum number of operations in one list I/O call. */ +#define _POSIX_AIO_LISTIO_MAX 2 + +/* Minimal number of outstanding asynchronous I/O operations. */ +#define _POSIX_AIO_MAX 1 + +/* Maximum length of arguments to `execve', including environment. */ +#define _POSIX_ARG_MAX 4096 + +/* Maximum simultaneous processes per real user ID. */ +#ifdef __USE_XOPEN2K +# define _POSIX_CHILD_MAX 25 +#else +# define _POSIX_CHILD_MAX 6 +#endif + +/* Minimal number of timer expiration overruns. */ +#define _POSIX_DELAYTIMER_MAX 32 + +/* Maximum length of a host name (not including the terminating null) + as returned from the GETHOSTNAME function. */ +#define _POSIX_HOST_NAME_MAX 255 + +/* Maximum link count of a file. */ +#define _POSIX_LINK_MAX 8 + +/* Maximum length of login name. */ +#define _POSIX_LOGIN_NAME_MAX 9 + +/* Number of bytes in a terminal canonical input queue. */ +#define _POSIX_MAX_CANON 255 + +/* Number of bytes for which space will be + available in a terminal input queue. */ +#define _POSIX_MAX_INPUT 255 + +/* Maximum number of message queues open for a process. */ +#define _POSIX_MQ_OPEN_MAX 8 + +/* Maximum number of supported message priorities. */ +#define _POSIX_MQ_PRIO_MAX 32 + +/* Number of bytes in a filename. */ +#define _POSIX_NAME_MAX 14 + +/* Number of simultaneous supplementary group IDs per process. */ +#ifdef __USE_XOPEN2K +# define _POSIX_NGROUPS_MAX 8 +#else +# define _POSIX_NGROUPS_MAX 0 +#endif + +/* Number of files one process can have open at once. */ +#ifdef __USE_XOPEN2K +# define _POSIX_OPEN_MAX 20 +#else +# define _POSIX_OPEN_MAX 16 +#endif + +#if !defined __USE_XOPEN2K || defined __USE_GNU +/* Number of descriptors that a process may examine with `pselect' or + `select'. */ +# define _POSIX_FD_SETSIZE _POSIX_OPEN_MAX +#endif + +/* Number of bytes in a pathname. */ +#define _POSIX_PATH_MAX 256 + +/* Number of bytes than can be written atomically to a pipe. */ +#define _POSIX_PIPE_BUF 512 + +/* The number of repeated occurrences of a BRE permitted by the + REGEXEC and REGCOMP functions when using the interval notation. */ +#define _POSIX_RE_DUP_MAX 255 + +/* Minimal number of realtime signals reserved for the application. */ +#define _POSIX_RTSIG_MAX 8 + +/* Number of semaphores a process can have. */ +#define _POSIX_SEM_NSEMS_MAX 256 + +/* Maximal value of a semaphore. */ +#define _POSIX_SEM_VALUE_MAX 32767 + +/* Number of pending realtime signals. */ +#define _POSIX_SIGQUEUE_MAX 32 + +/* Largest value of a `ssize_t'. */ +#define _POSIX_SSIZE_MAX 32767 + +/* Number of streams a process can have open at once. */ +#define _POSIX_STREAM_MAX 8 + +/* The number of bytes in a symbolic link. */ +#define _POSIX_SYMLINK_MAX 255 + +/* The number of symbolic links that can be traversed in the + resolution of a pathname in the absence of a loop. */ +#define _POSIX_SYMLOOP_MAX 8 + +/* Number of timer for a process. */ +#define _POSIX_TIMER_MAX 32 + +/* Maximum number of characters in a tty name. */ +#define _POSIX_TTY_NAME_MAX 9 + +/* Maximum length of a timezone name (element of `tzname'). */ +#ifdef __USE_XOPEN2K +# define _POSIX_TZNAME_MAX 6 +#else +# define _POSIX_TZNAME_MAX 3 +#endif + +#if !defined __USE_XOPEN2K || defined __USE_GNU +/* Maximum number of connections that can be queued on a socket. */ +# define _POSIX_QLIMIT 1 + +/* Maximum number of bytes that can be buffered on a socket for send + or receive. */ +# define _POSIX_HIWAT _POSIX_PIPE_BUF + +/* Maximum number of elements in an `iovec' array. */ +# define _POSIX_UIO_MAXIOV 16 +#endif + +/* Maximum clock resolution in nanoseconds. */ +#define _POSIX_CLOCKRES_MIN 20000000 + + +/* Get the implementation-specific values for the above. */ +#include + + +#ifndef SSIZE_MAX +# define SSIZE_MAX LONG_MAX +#endif + + +/* This value is a guaranteed minimum maximum. + The current maximum can be got from `sysconf'. */ + +#ifndef NGROUPS_MAX +# define NGROUPS_MAX 8 +#endif + +#endif /* bits/posix1_lim.h */ diff --git a/libktorrent/miniboost/bits/posix2_lim.h b/libktorrent/miniboost/bits/posix2_lim.h new file mode 100644 index 00000000..0dbdf1e6 --- /dev/null +++ b/libktorrent/miniboost/bits/posix2_lim.h @@ -0,0 +1,90 @@ +/* Copyright (C) 1991-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* + * Never include this file directly; include instead. + */ + +#ifndef _BITS_POSIX2_LIM_H +#define _BITS_POSIX2_LIM_H 1 + + +/* The maximum `ibase' and `obase' values allowed by the `bc' utility. */ +#define _POSIX2_BC_BASE_MAX 99 + +/* The maximum number of elements allowed in an array by the `bc' utility. */ +#define _POSIX2_BC_DIM_MAX 2048 + +/* The maximum `scale' value allowed by the `bc' utility. */ +#define _POSIX2_BC_SCALE_MAX 99 + +/* The maximum length of a string constant accepted by the `bc' utility. */ +#define _POSIX2_BC_STRING_MAX 1000 + +/* The maximum number of weights that can be assigned to an entry of + the LC_COLLATE `order' keyword in the locale definition file. */ +#define _POSIX2_COLL_WEIGHTS_MAX 2 + +/* The maximum number of expressions that can be nested + within parentheses by the `expr' utility. */ +#define _POSIX2_EXPR_NEST_MAX 32 + +/* The maximum length, in bytes, of an input line. */ +#define _POSIX2_LINE_MAX 2048 + +/* The maximum number of repeated occurrences of a regular expression + permitted when using the interval notation `\{M,N\}'. */ +#define _POSIX2_RE_DUP_MAX 255 + +/* The maximum number of bytes in a character class name. We have no + fixed limit, 2048 is a high number. */ +#define _POSIX2_CHARCLASS_NAME_MAX 14 + + +/* These values are implementation-specific, + and may vary within the implementation. + Their precise values can be obtained from sysconf. */ + +#ifndef BC_BASE_MAX +#define BC_BASE_MAX _POSIX2_BC_BASE_MAX +#endif +#ifndef BC_DIM_MAX +#define BC_DIM_MAX _POSIX2_BC_DIM_MAX +#endif +#ifndef BC_SCALE_MAX +#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX +#endif +#ifndef BC_STRING_MAX +#define BC_STRING_MAX _POSIX2_BC_STRING_MAX +#endif +#ifndef COLL_WEIGHTS_MAX +#define COLL_WEIGHTS_MAX 255 +#endif +#ifndef EXPR_NEST_MAX +#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX +#endif +#ifndef LINE_MAX +#define LINE_MAX _POSIX2_LINE_MAX +#endif +#ifndef CHARCLASS_NAME_MAX +#define CHARCLASS_NAME_MAX 2048 +#endif + +/* This value is defined like this in regex.h. */ +#define RE_DUP_MAX (0x7fff) + +#endif /* bits/posix2_lim.h */ diff --git a/libktorrent/miniboost/bits/posix_opt.h b/libktorrent/miniboost/bits/posix_opt.h new file mode 100644 index 00000000..6ca0753e --- /dev/null +++ b/libktorrent/miniboost/bits/posix_opt.h @@ -0,0 +1,191 @@ +/* Define POSIX options for Linux. + Copyright (C) 1996-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; see the file COPYING.LIB. If + not, see . */ + +#ifndef _BITS_POSIX_OPT_H +#define _BITS_POSIX_OPT_H 1 + +/* Job control is supported. */ +#define _POSIX_JOB_CONTROL 1 + +/* Processes have a saved set-user-ID and a saved set-group-ID. */ +#define _POSIX_SAVED_IDS 1 + +/* Priority scheduling is supported. */ +#define _POSIX_PRIORITY_SCHEDULING 200809L + +/* Synchronizing file data is supported. */ +#define _POSIX_SYNCHRONIZED_IO 200809L + +/* The fsync function is present. */ +#define _POSIX_FSYNC 200809L + +/* Mapping of files to memory is supported. */ +#define _POSIX_MAPPED_FILES 200809L + +/* Locking of all memory is supported. */ +#define _POSIX_MEMLOCK 200809L + +/* Locking of ranges of memory is supported. */ +#define _POSIX_MEMLOCK_RANGE 200809L + +/* Setting of memory protections is supported. */ +#define _POSIX_MEMORY_PROTECTION 200809L + +/* Some filesystems allow all users to change file ownership. */ +#define _POSIX_CHOWN_RESTRICTED 0 + +/* `c_cc' member of 'struct termios' structure can be disabled by + using the value _POSIX_VDISABLE. */ +#define _POSIX_VDISABLE '\0' + +/* Filenames are not silently truncated. */ +#define _POSIX_NO_TRUNC 1 + +/* X/Open realtime support is available. */ +#define _XOPEN_REALTIME 1 + +/* X/Open thread realtime support is available. */ +#define _XOPEN_REALTIME_THREADS 1 + +/* XPG4.2 shared memory is supported. */ +#define _XOPEN_SHM 1 + +/* Tell we have POSIX threads. */ +#define _POSIX_THREADS 200809L + +/* We have the reentrant functions described in POSIX. */ +#define _POSIX_REENTRANT_FUNCTIONS 1 +#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L + +/* We provide priority scheduling for threads. */ +#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L + +/* We support user-defined stack sizes. */ +#define _POSIX_THREAD_ATTR_STACKSIZE 200809L + +/* We support user-defined stacks. */ +#define _POSIX_THREAD_ATTR_STACKADDR 200809L + +/* We support priority inheritence. */ +#define _POSIX_THREAD_PRIO_INHERIT 200809L + +/* We support priority protection, though only for non-robust + mutexes. */ +#define _POSIX_THREAD_PRIO_PROTECT 200809L + +#ifdef __USE_XOPEN2K8 +/* We support priority inheritence for robust mutexes. */ +# define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L + +/* We do not support priority protection for robust mutexes. */ +# define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1 +#endif + +/* We support POSIX.1b semaphores. */ +#define _POSIX_SEMAPHORES 200809L + +/* Real-time signals are supported. */ +#define _POSIX_REALTIME_SIGNALS 200809L + +/* We support asynchronous I/O. */ +#define _POSIX_ASYNCHRONOUS_IO 200809L +#define _POSIX_ASYNC_IO 1 +/* Alternative name for Unix98. */ +#define _LFS_ASYNCHRONOUS_IO 1 +/* Support for prioritization is also available. */ +#define _POSIX_PRIORITIZED_IO 200809L + +/* The LFS support in asynchronous I/O is also available. */ +#define _LFS64_ASYNCHRONOUS_IO 1 + +/* The rest of the LFS is also available. */ +#define _LFS_LARGEFILE 1 +#define _LFS64_LARGEFILE 1 +#define _LFS64_STDIO 1 + +/* POSIX shared memory objects are implemented. */ +#define _POSIX_SHARED_MEMORY_OBJECTS 200809L + +/* CPU-time clocks support needs to be checked at runtime. */ +#define _POSIX_CPUTIME 0 + +/* Clock support in threads must be also checked at runtime. */ +#define _POSIX_THREAD_CPUTIME 0 + +/* GNU libc provides regular expression handling. */ +#define _POSIX_REGEXP 1 + +/* Reader/Writer locks are available. */ +#define _POSIX_READER_WRITER_LOCKS 200809L + +/* We have a POSIX shell. */ +#define _POSIX_SHELL 1 + +/* We support the Timeouts option. */ +#define _POSIX_TIMEOUTS 200809L + +/* We support spinlocks. */ +#define _POSIX_SPIN_LOCKS 200809L + +/* The `spawn' function family is supported. */ +#define _POSIX_SPAWN 200809L + +/* We have POSIX timers. */ +#define _POSIX_TIMERS 200809L + +/* The barrier functions are available. */ +#define _POSIX_BARRIERS 200809L + +/* POSIX message queues are available. */ +#define _POSIX_MESSAGE_PASSING 200809L + +/* Thread process-shared synchronization is supported. */ +#define _POSIX_THREAD_PROCESS_SHARED 200809L + +/* The monotonic clock might be available. */ +#define _POSIX_MONOTONIC_CLOCK 0 + +/* The clock selection interfaces are available. */ +#define _POSIX_CLOCK_SELECTION 200809L + +/* Advisory information interfaces are available. */ +#define _POSIX_ADVISORY_INFO 200809L + +/* IPv6 support is available. */ +#define _POSIX_IPV6 200809L + +/* Raw socket support is available. */ +#define _POSIX_RAW_SOCKETS 200809L + +/* We have at least one terminal. */ +#define _POSIX2_CHAR_TERM 200809L + +/* Neither process nor thread sporadic server interfaces is available. */ +#define _POSIX_SPORADIC_SERVER -1 +#define _POSIX_THREAD_SPORADIC_SERVER -1 + +/* trace.h is not available. */ +#define _POSIX_TRACE -1 +#define _POSIX_TRACE_EVENT_FILTER -1 +#define _POSIX_TRACE_INHERIT -1 +#define _POSIX_TRACE_LOG -1 + +/* Typed memory objects are not available. */ +#define _POSIX_TYPED_MEMORY_OBJECTS -1 + +#endif /* bits/posix_opt.h */ diff --git a/libktorrent/miniboost/bits/pthreadtypes.h b/libktorrent/miniboost/bits/pthreadtypes.h new file mode 100644 index 00000000..aad2e14c --- /dev/null +++ b/libktorrent/miniboost/bits/pthreadtypes.h @@ -0,0 +1,258 @@ +/* Copyright (C) 2002-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_PTHREADTYPES_H +#define _BITS_PTHREADTYPES_H 1 + +#include + +#ifdef __x86_64__ +# if __WORDSIZE == 64 +# define __SIZEOF_PTHREAD_ATTR_T 56 +# define __SIZEOF_PTHREAD_MUTEX_T 40 +# define __SIZEOF_PTHREAD_MUTEXATTR_T 4 +# define __SIZEOF_PTHREAD_COND_T 48 +# define __SIZEOF_PTHREAD_CONDATTR_T 4 +# define __SIZEOF_PTHREAD_RWLOCK_T 56 +# define __SIZEOF_PTHREAD_RWLOCKATTR_T 8 +# define __SIZEOF_PTHREAD_BARRIER_T 32 +# define __SIZEOF_PTHREAD_BARRIERATTR_T 4 +# else +# define __SIZEOF_PTHREAD_ATTR_T 32 +# define __SIZEOF_PTHREAD_MUTEX_T 32 +# define __SIZEOF_PTHREAD_MUTEXATTR_T 4 +# define __SIZEOF_PTHREAD_COND_T 48 +# define __SIZEOF_PTHREAD_CONDATTR_T 4 +# define __SIZEOF_PTHREAD_RWLOCK_T 44 +# define __SIZEOF_PTHREAD_RWLOCKATTR_T 8 +# define __SIZEOF_PTHREAD_BARRIER_T 20 +# define __SIZEOF_PTHREAD_BARRIERATTR_T 4 +# endif +#else +# define __SIZEOF_PTHREAD_ATTR_T 36 +# define __SIZEOF_PTHREAD_MUTEX_T 24 +# define __SIZEOF_PTHREAD_MUTEXATTR_T 4 +# define __SIZEOF_PTHREAD_COND_T 48 +# define __SIZEOF_PTHREAD_CONDATTR_T 4 +# define __SIZEOF_PTHREAD_RWLOCK_T 32 +# define __SIZEOF_PTHREAD_RWLOCKATTR_T 8 +# define __SIZEOF_PTHREAD_BARRIER_T 20 +# define __SIZEOF_PTHREAD_BARRIERATTR_T 4 +#endif + + +/* Thread identifiers. The structure of the attribute type is not + exposed on purpose. */ +typedef unsigned long int pthread_t; + + +union pthread_attr_t +{ + char __size[__SIZEOF_PTHREAD_ATTR_T]; + long int __align; +}; +#ifndef __have_pthread_attr_t +typedef union pthread_attr_t pthread_attr_t; +# define __have_pthread_attr_t 1 +#endif + + +#ifdef __x86_64__ +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; +#else +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +#endif + + +/* Data structures for mutex handling. The structure of the attribute + type is not exposed on purpose. */ +typedef union +{ + struct __pthread_mutex_s + { + int __lock; + unsigned int __count; + int __owner; +#ifdef __x86_64__ + unsigned int __nusers; +#endif + /* KIND must stay at this position in the structure to maintain + binary compatibility. */ + int __kind; +#ifdef __x86_64__ + short __spins; + short __elision; + __pthread_list_t __list; +# define __PTHREAD_MUTEX_HAVE_PREV 1 +/* Mutex __spins initializer used by PTHREAD_MUTEX_INITIALIZER. */ +# define __PTHREAD_SPINS 0, 0 +#else + unsigned int __nusers; + __extension__ union + { + struct + { + short __espins; + short __elision; +# define __spins __elision_data.__espins +# define __elision __elision_data.__elision +# define __PTHREAD_SPINS { 0, 0 } + } __elision_data; + __pthread_slist_t __list; + }; +#endif + } __data; + char __size[__SIZEOF_PTHREAD_MUTEX_T]; + long int __align; +} pthread_mutex_t; + +typedef union +{ + char __size[__SIZEOF_PTHREAD_MUTEXATTR_T]; + int __align; +} pthread_mutexattr_t; + + +/* Data structure for conditional variable handling. The structure of + the attribute type is not exposed on purpose. */ +typedef union +{ + struct + { + int __lock; + unsigned int __futex; + __extension__ unsigned long long int __total_seq; + __extension__ unsigned long long int __wakeup_seq; + __extension__ unsigned long long int __woken_seq; + void *__mutex; + unsigned int __nwaiters; + unsigned int __broadcast_seq; + } __data; + char __size[__SIZEOF_PTHREAD_COND_T]; + __extension__ long long int __align; +} pthread_cond_t; + +typedef union +{ + char __size[__SIZEOF_PTHREAD_CONDATTR_T]; + int __align; +} pthread_condattr_t; + + +/* Keys for thread-specific data */ +typedef unsigned int pthread_key_t; + + +/* Once-only execution */ +typedef int pthread_once_t; + + +#if defined __USE_UNIX98 || defined __USE_XOPEN2K +/* Data structure for read-write lock variable handling. The + structure of the attribute type is not exposed on purpose. */ +typedef union +{ +# ifdef __x86_64__ + struct + { + int __lock; + unsigned int __nr_readers; + unsigned int __readers_wakeup; + unsigned int __writer_wakeup; + unsigned int __nr_readers_queued; + unsigned int __nr_writers_queued; + int __writer; + int __shared; + signed char __rwelision; +# ifdef __ILP32__ + unsigned char __pad1[3]; +# define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0 } +# else + unsigned char __pad1[7]; +# define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0, 0, 0, 0, 0 } +# endif + unsigned long int __pad2; + /* FLAGS must stay at this position in the structure to maintain + binary compatibility. */ + unsigned int __flags; +# define __PTHREAD_RWLOCK_INT_FLAGS_SHARED 1 + } __data; +# else + struct + { + int __lock; + unsigned int __nr_readers; + unsigned int __readers_wakeup; + unsigned int __writer_wakeup; + unsigned int __nr_readers_queued; + unsigned int __nr_writers_queued; + /* FLAGS must stay at this position in the structure to maintain + binary compatibility. */ + unsigned char __flags; + unsigned char __shared; + signed char __rwelision; +# define __PTHREAD_RWLOCK_ELISION_EXTRA 0 + unsigned char __pad2; + int __writer; + } __data; +# endif + char __size[__SIZEOF_PTHREAD_RWLOCK_T]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[__SIZEOF_PTHREAD_RWLOCKATTR_T]; + long int __align; +} pthread_rwlockattr_t; +#endif + + +#ifdef __USE_XOPEN2K +/* POSIX spinlock data type. */ +typedef volatile int pthread_spinlock_t; + + +/* POSIX barriers data type. The structure of the type is + deliberately not exposed. */ +typedef union +{ + char __size[__SIZEOF_PTHREAD_BARRIER_T]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[__SIZEOF_PTHREAD_BARRIERATTR_T]; + int __align; +} pthread_barrierattr_t; +#endif + + +#ifndef __x86_64__ +/* Extra attributes for the cleanup functions. */ +# define __cleanup_fct_attribute __attribute__ ((__regparm__ (1))) +#endif + +#endif /* bits/pthreadtypes.h */ diff --git a/libktorrent/miniboost/bits/sched.h b/libktorrent/miniboost/bits/sched.h new file mode 100644 index 00000000..555529d6 --- /dev/null +++ b/libktorrent/miniboost/bits/sched.h @@ -0,0 +1,210 @@ +/* Definitions of constants and data structure for POSIX 1003.1b-1993 + scheduling interface. + Copyright (C) 1996-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef __need_schedparam + +#ifndef _SCHED_H +# error "Never include directly; use instead." +#endif + + +/* Scheduling algorithms. */ +#define SCHED_OTHER 0 +#define SCHED_FIFO 1 +#define SCHED_RR 2 +#ifdef __USE_GNU +# define SCHED_BATCH 3 +# define SCHED_IDLE 5 + +# define SCHED_RESET_ON_FORK 0x40000000 +#endif + +#ifdef __USE_GNU +/* Cloning flags. */ +# define CSIGNAL 0x000000ff /* Signal mask to be sent at exit. */ +# define CLONE_VM 0x00000100 /* Set if VM shared between processes. */ +# define CLONE_FS 0x00000200 /* Set if fs info shared between processes. */ +# define CLONE_FILES 0x00000400 /* Set if open files shared between processes. */ +# define CLONE_SIGHAND 0x00000800 /* Set if signal handlers shared. */ +# define CLONE_PTRACE 0x00002000 /* Set if tracing continues on the child. */ +# define CLONE_VFORK 0x00004000 /* Set if the parent wants the child to + wake it up on mm_release. */ +# define CLONE_PARENT 0x00008000 /* Set if we want to have the same + parent as the cloner. */ +# define CLONE_THREAD 0x00010000 /* Set to add to same thread group. */ +# define CLONE_NEWNS 0x00020000 /* Set to create new namespace. */ +# define CLONE_SYSVSEM 0x00040000 /* Set to shared SVID SEM_UNDO semantics. */ +# define CLONE_SETTLS 0x00080000 /* Set TLS info. */ +# define CLONE_PARENT_SETTID 0x00100000 /* Store TID in userlevel buffer + before MM copy. */ +# define CLONE_CHILD_CLEARTID 0x00200000 /* Register exit futex and memory + location to clear. */ +# define CLONE_DETACHED 0x00400000 /* Create clone detached. */ +# define CLONE_UNTRACED 0x00800000 /* Set if the tracing process can't + force CLONE_PTRACE on this clone. */ +# define CLONE_CHILD_SETTID 0x01000000 /* Store TID in userlevel buffer in + the child. */ +# define CLONE_NEWUTS 0x04000000 /* New utsname group. */ +# define CLONE_NEWIPC 0x08000000 /* New ipcs. */ +# define CLONE_NEWUSER 0x10000000 /* New user namespace. */ +# define CLONE_NEWPID 0x20000000 /* New pid namespace. */ +# define CLONE_NEWNET 0x40000000 /* New network namespace. */ +# define CLONE_IO 0x80000000 /* Clone I/O context. */ +#endif + +/* The official definition. */ +struct sched_param + { + int __sched_priority; + }; + +__BEGIN_DECLS + +#ifdef __USE_GNU +/* Clone current process. */ +extern int clone (int (*__fn) (void *__arg), void *__child_stack, + int __flags, void *__arg, ...) __THROW; + +/* Unshare the specified resources. */ +extern int unshare (int __flags) __THROW; + +/* Get index of currently used CPU. */ +extern int sched_getcpu (void) __THROW; + +/* Switch process to namespace of type NSTYPE indicated by FD. */ +extern int setns (int __fd, int __nstype) __THROW; +#endif + + +__END_DECLS + +#endif /* need schedparam */ + +#if !defined __defined_schedparam \ + && (defined __need_schedparam || defined _SCHED_H) +# define __defined_schedparam 1 +/* Data structure to describe a process' schedulability. */ +struct __sched_param + { + int __sched_priority; + }; +# undef __need_schedparam +#endif + + +#if defined _SCHED_H && !defined __cpu_set_t_defined +# define __cpu_set_t_defined +/* Size definition for CPU sets. */ +# define __CPU_SETSIZE 1024 +# define __NCPUBITS (8 * sizeof (__cpu_mask)) + +/* Type for array elements in 'cpu_set_t'. */ +typedef unsigned long int __cpu_mask; + +/* Basic access functions. */ +# define __CPUELT(cpu) ((cpu) / __NCPUBITS) +# define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS)) + +/* Data structure to describe CPU mask. */ +typedef struct +{ + __cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS]; +} cpu_set_t; + +/* Access functions for CPU masks. */ +# if __GNUC_PREREQ (2, 91) +# define __CPU_ZERO_S(setsize, cpusetp) \ + do __builtin_memset (cpusetp, '\0', setsize); while (0) +# else +# define __CPU_ZERO_S(setsize, cpusetp) \ + do { \ + size_t __i; \ + size_t __imax = (setsize) / sizeof (__cpu_mask); \ + __cpu_mask *__bits = (cpusetp)->__bits; \ + for (__i = 0; __i < __imax; ++__i) \ + __bits[__i] = 0; \ + } while (0) +# endif +# define __CPU_SET_S(cpu, setsize, cpusetp) \ + (__extension__ \ + ({ size_t __cpu = (cpu); \ + __cpu / 8 < (setsize) \ + ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ + |= __CPUMASK (__cpu)) \ + : 0; })) +# define __CPU_CLR_S(cpu, setsize, cpusetp) \ + (__extension__ \ + ({ size_t __cpu = (cpu); \ + __cpu / 8 < (setsize) \ + ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ + &= ~__CPUMASK (__cpu)) \ + : 0; })) +# define __CPU_ISSET_S(cpu, setsize, cpusetp) \ + (__extension__ \ + ({ size_t __cpu = (cpu); \ + __cpu / 8 < (setsize) \ + ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ + & __CPUMASK (__cpu))) != 0 \ + : 0; })) + +# define __CPU_COUNT_S(setsize, cpusetp) \ + __sched_cpucount (setsize, cpusetp) + +# if __GNUC_PREREQ (2, 91) +# define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ + (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0) +# else +# define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ + (__extension__ \ + ({ const __cpu_mask *__arr1 = (cpusetp1)->__bits; \ + const __cpu_mask *__arr2 = (cpusetp2)->__bits; \ + size_t __imax = (setsize) / sizeof (__cpu_mask); \ + size_t __i; \ + for (__i = 0; __i < __imax; ++__i) \ + if (__arr1[__i] != __arr2[__i]) \ + break; \ + __i == __imax; })) +# endif + +# define __CPU_OP_S(setsize, destset, srcset1, srcset2, op) \ + (__extension__ \ + ({ cpu_set_t *__dest = (destset); \ + const __cpu_mask *__arr1 = (srcset1)->__bits; \ + const __cpu_mask *__arr2 = (srcset2)->__bits; \ + size_t __imax = (setsize) / sizeof (__cpu_mask); \ + size_t __i; \ + for (__i = 0; __i < __imax; ++__i) \ + ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; \ + __dest; })) + +# define __CPU_ALLOC_SIZE(count) \ + ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask)) +# define __CPU_ALLOC(count) __sched_cpualloc (count) +# define __CPU_FREE(cpuset) __sched_cpufree (cpuset) + +__BEGIN_DECLS + +extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) + __THROW; +extern cpu_set_t *__sched_cpualloc (size_t __count) __THROW __wur; +extern void __sched_cpufree (cpu_set_t *__set) __THROW; + +__END_DECLS + +#endif diff --git a/libktorrent/miniboost/bits/select.h b/libktorrent/miniboost/bits/select.h new file mode 100644 index 00000000..6e9c4f1d --- /dev/null +++ b/libktorrent/miniboost/bits/select.h @@ -0,0 +1,63 @@ +/* Copyright (C) 1997-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SYS_SELECT_H +# error "Never use directly; include instead." +#endif + +#include + + +#if defined __GNUC__ && __GNUC__ >= 2 + +# if __WORDSIZE == 64 +# define __FD_ZERO_STOS "stosq" +# else +# define __FD_ZERO_STOS "stosl" +# endif + +# define __FD_ZERO(fdsp) \ + do { \ + int __d0, __d1; \ + __asm__ __volatile__ ("cld; rep; " __FD_ZERO_STOS \ + : "=c" (__d0), "=D" (__d1) \ + : "a" (0), "0" (sizeof (fd_set) \ + / sizeof (__fd_mask)), \ + "1" (&__FDS_BITS (fdsp)[0]) \ + : "memory"); \ + } while (0) + +#else /* ! GNU CC */ + +/* We don't use `memset' because this would require a prototype and + the array isn't too big. */ +# define __FD_ZERO(set) \ + do { \ + unsigned int __i; \ + fd_set *__arr = (set); \ + for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) \ + __FDS_BITS (__arr)[__i] = 0; \ + } while (0) + +#endif /* GNU CC */ + +#define __FD_SET(d, set) \ + ((void) (__FDS_BITS (set)[__FD_ELT (d)] |= __FD_MASK (d))) +#define __FD_CLR(d, set) \ + ((void) (__FDS_BITS (set)[__FD_ELT (d)] &= ~__FD_MASK (d))) +#define __FD_ISSET(d, set) \ + ((__FDS_BITS (set)[__FD_ELT (d)] & __FD_MASK (d)) != 0) diff --git a/libktorrent/miniboost/bits/select2.h b/libktorrent/miniboost/bits/select2.h new file mode 100644 index 00000000..8906ba1f --- /dev/null +++ b/libktorrent/miniboost/bits/select2.h @@ -0,0 +1,35 @@ +/* Checking macros for select functions. + Copyright (C) 2011-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SYS_SELECT_H +# error "Never include directly; use instead." +#endif + +/* Helper functions to issue warnings and errors when needed. */ +extern long int __fdelt_chk (long int __d); +extern long int __fdelt_warn (long int __d) + __warnattr ("bit outside of fd_set selected"); +#undef __FD_ELT +#define __FD_ELT(d) \ + __extension__ \ + ({ long int __d = (d); \ + (__builtin_constant_p (__d) \ + ? (0 <= __d && __d < __FD_SETSIZE \ + ? (__d / __NFDBITS) \ + : __fdelt_warn (__d)) \ + : __fdelt_chk (__d)); }) diff --git a/libktorrent/miniboost/bits/setjmp.h b/libktorrent/miniboost/bits/setjmp.h new file mode 100644 index 00000000..a261eb70 --- /dev/null +++ b/libktorrent/miniboost/bits/setjmp.h @@ -0,0 +1,40 @@ +/* Copyright (C) 2001-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* Define the machine-dependent type `jmp_buf'. x86-64 version. */ +#ifndef _BITS_SETJMP_H +#define _BITS_SETJMP_H 1 + +#if !defined _SETJMP_H && !defined _PTHREAD_H +# error "Never include directly; use instead." +#endif + +#include + +#ifndef _ASM + +# if __WORDSIZE == 64 +typedef long int __jmp_buf[8]; +# elif defined __x86_64__ +__extension__ typedef long long int __jmp_buf[8]; +# else +typedef int __jmp_buf[6]; +# endif + +#endif + +#endif /* bits/setjmp.h */ diff --git a/libktorrent/miniboost/bits/sigaction.h b/libktorrent/miniboost/bits/sigaction.h new file mode 100644 index 00000000..eb09e818 --- /dev/null +++ b/libktorrent/miniboost/bits/sigaction.h @@ -0,0 +1,78 @@ +/* The proper definitions for Linux's sigaction. + Copyright (C) 1993-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SIGNAL_H +# error "Never include directly; use instead." +#endif + +/* Structure describing the action to be taken when a signal arrives. */ +struct sigaction + { + /* Signal handler. */ +#ifdef __USE_POSIX199309 + union + { + /* Used if SA_SIGINFO is not set. */ + __sighandler_t sa_handler; + /* Used if SA_SIGINFO is set. */ + void (*sa_sigaction) (int, siginfo_t *, void *); + } + __sigaction_handler; +# define sa_handler __sigaction_handler.sa_handler +# define sa_sigaction __sigaction_handler.sa_sigaction +#else + __sighandler_t sa_handler; +#endif + + /* Additional set of signals to be blocked. */ + __sigset_t sa_mask; + + /* Special flags. */ + int sa_flags; + + /* Restore handler. */ + void (*sa_restorer) (void); + }; + +/* Bits in `sa_flags'. */ +#define SA_NOCLDSTOP 1 /* Don't send SIGCHLD when children stop. */ +#define SA_NOCLDWAIT 2 /* Don't create zombie on child death. */ +#define SA_SIGINFO 4 /* Invoke signal-catching function with + three arguments instead of one. */ +#if defined __USE_UNIX98 || defined __USE_MISC +# define SA_ONSTACK 0x08000000 /* Use signal stack by using `sa_restorer'. */ +#endif +#if defined __USE_UNIX98 || defined __USE_XOPEN2K8 +# define SA_RESTART 0x10000000 /* Restart syscall on signal return. */ +# define SA_NODEFER 0x40000000 /* Don't automatically block the signal when + its handler is being executed. */ +# define SA_RESETHAND 0x80000000 /* Reset to SIG_DFL on entry to handler. */ +#endif +#ifdef __USE_MISC +# define SA_INTERRUPT 0x20000000 /* Historical no-op. */ + +/* Some aliases for the SA_ constants. */ +# define SA_NOMASK SA_NODEFER +# define SA_ONESHOT SA_RESETHAND +# define SA_STACK SA_ONSTACK +#endif + +/* Values for the HOW argument to `sigprocmask'. */ +#define SIG_BLOCK 0 /* Block signals. */ +#define SIG_UNBLOCK 1 /* Unblock signals. */ +#define SIG_SETMASK 2 /* Set the set of blocked signals. */ diff --git a/libktorrent/miniboost/bits/sigcontext.h b/libktorrent/miniboost/bits/sigcontext.h new file mode 100644 index 00000000..e742cba7 --- /dev/null +++ b/libktorrent/miniboost/bits/sigcontext.h @@ -0,0 +1,194 @@ +/* Copyright (C) 2002-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_SIGCONTEXT_H +#define _BITS_SIGCONTEXT_H 1 + +#if !defined _SIGNAL_H && !defined _SYS_UCONTEXT_H +# error "Never use directly; include instead." +#endif + +#define FP_XSTATE_MAGIC1 0x46505853U +#define FP_XSTATE_MAGIC2 0x46505845U +#define FP_XSTATE_MAGIC2_SIZE sizeof(FP_XSTATE_MAGIC2) + +struct _fpx_sw_bytes +{ + __uint32_t magic1; + __uint32_t extended_size; + __uint64_t xstate_bv; + __uint32_t xstate_size; + __uint32_t padding[7]; +}; + +struct _fpreg +{ + unsigned short significand[4]; + unsigned short exponent; +}; + +struct _fpxreg +{ + unsigned short significand[4]; + unsigned short exponent; + unsigned short padding[3]; +}; + +struct _xmmreg +{ + __uint32_t element[4]; +}; + + + +#ifndef __x86_64__ + +struct _fpstate +{ + /* Regular FPU environment. */ + __uint32_t cw; + __uint32_t sw; + __uint32_t tag; + __uint32_t ipoff; + __uint32_t cssel; + __uint32_t dataoff; + __uint32_t datasel; + struct _fpreg _st[8]; + unsigned short status; + unsigned short magic; + + /* FXSR FPU environment. */ + __uint32_t _fxsr_env[6]; + __uint32_t mxcsr; + __uint32_t reserved; + struct _fpxreg _fxsr_st[8]; + struct _xmmreg _xmm[8]; + __uint32_t padding[56]; +}; + +#ifndef sigcontext_struct +/* Kernel headers before 2.1.1 define a struct sigcontext_struct, but + we need sigcontext. Some packages have come to rely on + sigcontext_struct being defined on 32-bit x86, so define this for + their benefit. */ +# define sigcontext_struct sigcontext +#endif + +#define X86_FXSR_MAGIC 0x0000 + +struct sigcontext +{ + unsigned short gs, __gsh; + unsigned short fs, __fsh; + unsigned short es, __esh; + unsigned short ds, __dsh; + unsigned long edi; + unsigned long esi; + unsigned long ebp; + unsigned long esp; + unsigned long ebx; + unsigned long edx; + unsigned long ecx; + unsigned long eax; + unsigned long trapno; + unsigned long err; + unsigned long eip; + unsigned short cs, __csh; + unsigned long eflags; + unsigned long esp_at_signal; + unsigned short ss, __ssh; + struct _fpstate * fpstate; + unsigned long oldmask; + unsigned long cr2; +}; + +#else /* __x86_64__ */ + +struct _fpstate +{ + /* FPU environment matching the 64-bit FXSAVE layout. */ + __uint16_t cwd; + __uint16_t swd; + __uint16_t ftw; + __uint16_t fop; + __uint64_t rip; + __uint64_t rdp; + __uint32_t mxcsr; + __uint32_t mxcr_mask; + struct _fpxreg _st[8]; + struct _xmmreg _xmm[16]; + __uint32_t padding[24]; +}; + +struct sigcontext +{ + __uint64_t r8; + __uint64_t r9; + __uint64_t r10; + __uint64_t r11; + __uint64_t r12; + __uint64_t r13; + __uint64_t r14; + __uint64_t r15; + __uint64_t rdi; + __uint64_t rsi; + __uint64_t rbp; + __uint64_t rbx; + __uint64_t rdx; + __uint64_t rax; + __uint64_t rcx; + __uint64_t rsp; + __uint64_t rip; + __uint64_t eflags; + unsigned short cs; + unsigned short gs; + unsigned short fs; + unsigned short __pad0; + __uint64_t err; + __uint64_t trapno; + __uint64_t oldmask; + __uint64_t cr2; + __extension__ union + { + struct _fpstate * fpstate; + __uint64_t __fpstate_word; + }; + __uint64_t __reserved1 [8]; +}; + +#endif /* __x86_64__ */ + +struct _xsave_hdr +{ + __uint64_t xstate_bv; + __uint64_t reserved1[2]; + __uint64_t reserved2[5]; +}; + +struct _ymmh_state +{ + __uint32_t ymmh_space[64]; +}; + +struct _xstate +{ + struct _fpstate fpstate; + struct _xsave_hdr xstate_hdr; + struct _ymmh_state ymmh; +}; + +#endif /* _BITS_SIGCONTEXT_H */ diff --git a/libktorrent/miniboost/bits/siginfo.h b/libktorrent/miniboost/bits/siginfo.h new file mode 100644 index 00000000..759fc3e6 --- /dev/null +++ b/libktorrent/miniboost/bits/siginfo.h @@ -0,0 +1,353 @@ +/* siginfo_t, sigevent and constants. Linux x86-64 version. + Copyright (C) 2012-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#if !defined _SIGNAL_H && !defined __need_siginfo_t \ + && !defined __need_sigevent_t +# error "Never include this file directly. Use instead" +#endif + +#include + +#if (!defined __have_sigval_t \ + && (defined _SIGNAL_H || defined __need_siginfo_t \ + || defined __need_sigevent_t)) +# define __have_sigval_t 1 + +/* Type for data associated with a signal. */ +typedef union sigval + { + int sival_int; + void *sival_ptr; + } sigval_t; +#endif + +#if (!defined __have_siginfo_t \ + && (defined _SIGNAL_H || defined __need_siginfo_t)) +# define __have_siginfo_t 1 + +# define __SI_MAX_SIZE 128 +# if __WORDSIZE == 64 +# define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 4) +# else +# define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 3) +# endif + +# if defined __x86_64__ && __WORDSIZE == 32 +/* si_utime and si_stime must be 4 byte aligned for x32 to match the + kernel. We align siginfo_t to 8 bytes so that si_utime and si_stime + are actually aligned to 8 bytes since their offsets are multiple of + 8 bytes. */ +typedef __clock_t __attribute__ ((__aligned__ (4))) __sigchld_clock_t; +# define __SI_ALIGNMENT __attribute__ ((__aligned__ (8))) +# else +typedef __clock_t __sigchld_clock_t; +# define __SI_ALIGNMENT +# endif + +typedef struct + { + int si_signo; /* Signal number. */ + int si_errno; /* If non-zero, an errno value associated with + this signal, as defined in . */ + int si_code; /* Signal code. */ + + union + { + int _pad[__SI_PAD_SIZE]; + + /* kill(). */ + struct + { + __pid_t si_pid; /* Sending process ID. */ + __uid_t si_uid; /* Real user ID of sending process. */ + } _kill; + + /* POSIX.1b timers. */ + struct + { + int si_tid; /* Timer ID. */ + int si_overrun; /* Overrun count. */ + sigval_t si_sigval; /* Signal value. */ + } _timer; + + /* POSIX.1b signals. */ + struct + { + __pid_t si_pid; /* Sending process ID. */ + __uid_t si_uid; /* Real user ID of sending process. */ + sigval_t si_sigval; /* Signal value. */ + } _rt; + + /* SIGCHLD. */ + struct + { + __pid_t si_pid; /* Which child. */ + __uid_t si_uid; /* Real user ID of sending process. */ + int si_status; /* Exit value or signal. */ + __sigchld_clock_t si_utime; + __sigchld_clock_t si_stime; + } _sigchld; + + /* SIGILL, SIGFPE, SIGSEGV, SIGBUS. */ + struct + { + void *si_addr; /* Faulting insn/memory ref. */ + short int si_addr_lsb; /* Valid LSB of the reported address. */ + } _sigfault; + + /* SIGPOLL. */ + struct + { + long int si_band; /* Band event for SIGPOLL. */ + int si_fd; + } _sigpoll; + + /* SIGSYS. */ + struct + { + void *_call_addr; /* Calling user insn. */ + int _syscall; /* Triggering system call number. */ + unsigned int _arch; /* AUDIT_ARCH_* of syscall. */ + } _sigsys; + } _sifields; + } siginfo_t __SI_ALIGNMENT; + + +/* X/Open requires some more fields with fixed names. */ +# define si_pid _sifields._kill.si_pid +# define si_uid _sifields._kill.si_uid +# define si_timerid _sifields._timer.si_tid +# define si_overrun _sifields._timer.si_overrun +# define si_status _sifields._sigchld.si_status +# define si_utime _sifields._sigchld.si_utime +# define si_stime _sifields._sigchld.si_stime +# define si_value _sifields._rt.si_sigval +# define si_int _sifields._rt.si_sigval.sival_int +# define si_ptr _sifields._rt.si_sigval.sival_ptr +# define si_addr _sifields._sigfault.si_addr +# define si_addr_lsb _sifields._sigfault.si_addr_lsb +# define si_band _sifields._sigpoll.si_band +# define si_fd _sifields._sigpoll.si_fd +# define si_call_addr _sifields._sigsys._call_addr +# define si_syscall _sifields._sigsys._syscall +# define si_arch _sifields._sigsys._arch + + +/* Values for `si_code'. Positive values are reserved for kernel-generated + signals. */ +enum +{ + SI_ASYNCNL = -60, /* Sent by asynch name lookup completion. */ +# define SI_ASYNCNL SI_ASYNCNL + SI_TKILL = -6, /* Sent by tkill. */ +# define SI_TKILL SI_TKILL + SI_SIGIO, /* Sent by queued SIGIO. */ +# define SI_SIGIO SI_SIGIO + SI_ASYNCIO, /* Sent by AIO completion. */ +# define SI_ASYNCIO SI_ASYNCIO + SI_MESGQ, /* Sent by real time mesq state change. */ +# define SI_MESGQ SI_MESGQ + SI_TIMER, /* Sent by timer expiration. */ +# define SI_TIMER SI_TIMER + SI_QUEUE, /* Sent by sigqueue. */ +# define SI_QUEUE SI_QUEUE + SI_USER, /* Sent by kill, sigsend. */ +# define SI_USER SI_USER + SI_KERNEL = 0x80 /* Send by kernel. */ +#define SI_KERNEL SI_KERNEL +}; + + +# if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 +/* `si_code' values for SIGILL signal. */ +enum +{ + ILL_ILLOPC = 1, /* Illegal opcode. */ +# define ILL_ILLOPC ILL_ILLOPC + ILL_ILLOPN, /* Illegal operand. */ +# define ILL_ILLOPN ILL_ILLOPN + ILL_ILLADR, /* Illegal addressing mode. */ +# define ILL_ILLADR ILL_ILLADR + ILL_ILLTRP, /* Illegal trap. */ +# define ILL_ILLTRP ILL_ILLTRP + ILL_PRVOPC, /* Privileged opcode. */ +# define ILL_PRVOPC ILL_PRVOPC + ILL_PRVREG, /* Privileged register. */ +# define ILL_PRVREG ILL_PRVREG + ILL_COPROC, /* Coprocessor error. */ +# define ILL_COPROC ILL_COPROC + ILL_BADSTK /* Internal stack error. */ +# define ILL_BADSTK ILL_BADSTK +}; + +/* `si_code' values for SIGFPE signal. */ +enum +{ + FPE_INTDIV = 1, /* Integer divide by zero. */ +# define FPE_INTDIV FPE_INTDIV + FPE_INTOVF, /* Integer overflow. */ +# define FPE_INTOVF FPE_INTOVF + FPE_FLTDIV, /* Floating point divide by zero. */ +# define FPE_FLTDIV FPE_FLTDIV + FPE_FLTOVF, /* Floating point overflow. */ +# define FPE_FLTOVF FPE_FLTOVF + FPE_FLTUND, /* Floating point underflow. */ +# define FPE_FLTUND FPE_FLTUND + FPE_FLTRES, /* Floating point inexact result. */ +# define FPE_FLTRES FPE_FLTRES + FPE_FLTINV, /* Floating point invalid operation. */ +# define FPE_FLTINV FPE_FLTINV + FPE_FLTSUB /* Subscript out of range. */ +# define FPE_FLTSUB FPE_FLTSUB +}; + +/* `si_code' values for SIGSEGV signal. */ +enum +{ + SEGV_MAPERR = 1, /* Address not mapped to object. */ +# define SEGV_MAPERR SEGV_MAPERR + SEGV_ACCERR /* Invalid permissions for mapped object. */ +# define SEGV_ACCERR SEGV_ACCERR +}; + +/* `si_code' values for SIGBUS signal. */ +enum +{ + BUS_ADRALN = 1, /* Invalid address alignment. */ +# define BUS_ADRALN BUS_ADRALN + BUS_ADRERR, /* Non-existant physical address. */ +# define BUS_ADRERR BUS_ADRERR + BUS_OBJERR, /* Object specific hardware error. */ +# define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO +}; +# endif + +# ifdef __USE_XOPEN_EXTENDED +/* `si_code' values for SIGTRAP signal. */ +enum +{ + TRAP_BRKPT = 1, /* Process breakpoint. */ +# define TRAP_BRKPT TRAP_BRKPT + TRAP_TRACE /* Process trace trap. */ +# define TRAP_TRACE TRAP_TRACE +}; +# endif + +# if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 +/* `si_code' values for SIGCHLD signal. */ +enum +{ + CLD_EXITED = 1, /* Child has exited. */ +# define CLD_EXITED CLD_EXITED + CLD_KILLED, /* Child was killed. */ +# define CLD_KILLED CLD_KILLED + CLD_DUMPED, /* Child terminated abnormally. */ +# define CLD_DUMPED CLD_DUMPED + CLD_TRAPPED, /* Traced child has trapped. */ +# define CLD_TRAPPED CLD_TRAPPED + CLD_STOPPED, /* Child has stopped. */ +# define CLD_STOPPED CLD_STOPPED + CLD_CONTINUED /* Stopped child has continued. */ +# define CLD_CONTINUED CLD_CONTINUED +}; + +/* `si_code' values for SIGPOLL signal. */ +enum +{ + POLL_IN = 1, /* Data input available. */ +# define POLL_IN POLL_IN + POLL_OUT, /* Output buffers available. */ +# define POLL_OUT POLL_OUT + POLL_MSG, /* Input message available. */ +# define POLL_MSG POLL_MSG + POLL_ERR, /* I/O error. */ +# define POLL_ERR POLL_ERR + POLL_PRI, /* High priority input available. */ +# define POLL_PRI POLL_PRI + POLL_HUP /* Device disconnected. */ +# define POLL_HUP POLL_HUP +}; +# endif + +# undef __need_siginfo_t +#endif /* !have siginfo_t && (have _SIGNAL_H || need siginfo_t). */ + + +#if (defined _SIGNAL_H || defined __need_sigevent_t) \ + && !defined __have_sigevent_t +# define __have_sigevent_t 1 + +/* Structure to transport application-defined values with signals. */ +# define __SIGEV_MAX_SIZE 64 +# if __WORDSIZE == 64 +# define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 4) +# else +# define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 3) +# endif + +/* Forward declaration. */ +# ifndef __have_pthread_attr_t +typedef union pthread_attr_t pthread_attr_t; +# define __have_pthread_attr_t 1 +# endif + +typedef struct sigevent + { + sigval_t sigev_value; + int sigev_signo; + int sigev_notify; + + union + { + int _pad[__SIGEV_PAD_SIZE]; + + /* When SIGEV_SIGNAL and SIGEV_THREAD_ID set, LWP ID of the + thread to receive the signal. */ + __pid_t _tid; + + struct + { + void (*_function) (sigval_t); /* Function to start. */ + pthread_attr_t *_attribute; /* Thread attributes. */ + } _sigev_thread; + } _sigev_un; + } sigevent_t; + +/* POSIX names to access some of the members. */ +# define sigev_notify_function _sigev_un._sigev_thread._function +# define sigev_notify_attributes _sigev_un._sigev_thread._attribute + +/* `sigev_notify' values. */ +enum +{ + SIGEV_SIGNAL = 0, /* Notify via signal. */ +# define SIGEV_SIGNAL SIGEV_SIGNAL + SIGEV_NONE, /* Other notification: meaningless. */ +# define SIGEV_NONE SIGEV_NONE + SIGEV_THREAD, /* Deliver via thread creation. */ +# define SIGEV_THREAD SIGEV_THREAD + + SIGEV_THREAD_ID = 4 /* Send signal to specific thread. */ +#define SIGEV_THREAD_ID SIGEV_THREAD_ID +}; + +#endif /* have _SIGNAL_H. */ diff --git a/libktorrent/miniboost/bits/signum.h b/libktorrent/miniboost/bits/signum.h new file mode 100644 index 00000000..3305a478 --- /dev/null +++ b/libktorrent/miniboost/bits/signum.h @@ -0,0 +1,79 @@ +/* Signal number definitions. Linux version. + Copyright (C) 1995-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifdef _SIGNAL_H + +/* Fake signal functions. */ +#define SIG_ERR ((__sighandler_t) -1) /* Error return. */ +#define SIG_DFL ((__sighandler_t) 0) /* Default action. */ +#define SIG_IGN ((__sighandler_t) 1) /* Ignore signal. */ + +#ifdef __USE_UNIX98 +# define SIG_HOLD ((__sighandler_t) 2) /* Add signal to hold mask. */ +#endif + + +/* Signals. */ +#define SIGHUP 1 /* Hangup (POSIX). */ +#define SIGINT 2 /* Interrupt (ANSI). */ +#define SIGQUIT 3 /* Quit (POSIX). */ +#define SIGILL 4 /* Illegal instruction (ANSI). */ +#define SIGTRAP 5 /* Trace trap (POSIX). */ +#define SIGABRT 6 /* Abort (ANSI). */ +#define SIGIOT 6 /* IOT trap (4.2 BSD). */ +#define SIGBUS 7 /* BUS error (4.2 BSD). */ +#define SIGFPE 8 /* Floating-point exception (ANSI). */ +#define SIGKILL 9 /* Kill, unblockable (POSIX). */ +#define SIGUSR1 10 /* User-defined signal 1 (POSIX). */ +#define SIGSEGV 11 /* Segmentation violation (ANSI). */ +#define SIGUSR2 12 /* User-defined signal 2 (POSIX). */ +#define SIGPIPE 13 /* Broken pipe (POSIX). */ +#define SIGALRM 14 /* Alarm clock (POSIX). */ +#define SIGTERM 15 /* Termination (ANSI). */ +#define SIGSTKFLT 16 /* Stack fault. */ +#define SIGCLD SIGCHLD /* Same as SIGCHLD (System V). */ +#define SIGCHLD 17 /* Child status has changed (POSIX). */ +#define SIGCONT 18 /* Continue (POSIX). */ +#define SIGSTOP 19 /* Stop, unblockable (POSIX). */ +#define SIGTSTP 20 /* Keyboard stop (POSIX). */ +#define SIGTTIN 21 /* Background read from tty (POSIX). */ +#define SIGTTOU 22 /* Background write to tty (POSIX). */ +#define SIGURG 23 /* Urgent condition on socket (4.2 BSD). */ +#define SIGXCPU 24 /* CPU limit exceeded (4.2 BSD). */ +#define SIGXFSZ 25 /* File size limit exceeded (4.2 BSD). */ +#define SIGVTALRM 26 /* Virtual alarm clock (4.2 BSD). */ +#define SIGPROF 27 /* Profiling alarm clock (4.2 BSD). */ +#define SIGWINCH 28 /* Window size change (4.3 BSD, Sun). */ +#define SIGPOLL SIGIO /* Pollable event occurred (System V). */ +#define SIGIO 29 /* I/O now possible (4.2 BSD). */ +#define SIGPWR 30 /* Power failure restart (System V). */ +#define SIGSYS 31 /* Bad system call. */ +#define SIGUNUSED 31 + +#define _NSIG 65 /* Biggest signal number + 1 + (including real-time signals). */ + +#define SIGRTMIN (__libc_current_sigrtmin ()) +#define SIGRTMAX (__libc_current_sigrtmax ()) + +/* These are the hard limits of the kernel. These values should not be + used directly at user level. */ +#define __SIGRTMIN 32 +#define __SIGRTMAX (_NSIG - 1) + +#endif /* included. */ diff --git a/libktorrent/miniboost/bits/sigset.h b/libktorrent/miniboost/bits/sigset.h new file mode 100644 index 00000000..af4ae837 --- /dev/null +++ b/libktorrent/miniboost/bits/sigset.h @@ -0,0 +1,124 @@ +/* __sig_atomic_t, __sigset_t, and related definitions. Linux version. + Copyright (C) 1991-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SIGSET_H_types +# define _SIGSET_H_types 1 + +typedef int __sig_atomic_t; + +/* A `sigset_t' has a bit for each signal. */ + +# define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int))) +typedef struct + { + unsigned long int __val[_SIGSET_NWORDS]; + } __sigset_t; + +#endif + + +/* We only want to define these functions if was actually + included; otherwise we were included just to define the types. Since we + are namespace-clean, it wouldn't hurt to define extra macros. But + trouble can be caused by functions being defined (e.g., any global + register vars declared later will cause compilation errors). */ + +#if !defined _SIGSET_H_fns && defined _SIGNAL_H +# define _SIGSET_H_fns 1 + +# ifndef _EXTERN_INLINE +# define _EXTERN_INLINE __extern_inline +# endif + +/* Return a mask that includes the bit for SIG only. */ +# define __sigmask(sig) \ + (((unsigned long int) 1) << (((sig) - 1) % (8 * sizeof (unsigned long int)))) + +/* Return the word index for SIG. */ +# define __sigword(sig) (((sig) - 1) / (8 * sizeof (unsigned long int))) + +# if defined __GNUC__ && __GNUC__ >= 2 +# define __sigemptyset(set) \ + (__extension__ ({ int __cnt = _SIGSET_NWORDS; \ + sigset_t *__set = (set); \ + while (--__cnt >= 0) __set->__val[__cnt] = 0; \ + 0; })) +# define __sigfillset(set) \ + (__extension__ ({ int __cnt = _SIGSET_NWORDS; \ + sigset_t *__set = (set); \ + while (--__cnt >= 0) __set->__val[__cnt] = ~0UL; \ + 0; })) + +# ifdef __USE_GNU +/* The POSIX does not specify for handling the whole signal set in one + command. This is often wanted and so we define three more functions + here. */ +# define __sigisemptyset(set) \ + (__extension__ ({ int __cnt = _SIGSET_NWORDS; \ + const sigset_t *__set = (set); \ + int __ret = __set->__val[--__cnt]; \ + while (!__ret && --__cnt >= 0) \ + __ret = __set->__val[__cnt]; \ + __ret == 0; })) +# define __sigandset(dest, left, right) \ + (__extension__ ({ int __cnt = _SIGSET_NWORDS; \ + sigset_t *__dest = (dest); \ + const sigset_t *__left = (left); \ + const sigset_t *__right = (right); \ + while (--__cnt >= 0) \ + __dest->__val[__cnt] = (__left->__val[__cnt] \ + & __right->__val[__cnt]); \ + 0; })) +# define __sigorset(dest, left, right) \ + (__extension__ ({ int __cnt = _SIGSET_NWORDS; \ + sigset_t *__dest = (dest); \ + const sigset_t *__left = (left); \ + const sigset_t *__right = (right); \ + while (--__cnt >= 0) \ + __dest->__val[__cnt] = (__left->__val[__cnt] \ + | __right->__val[__cnt]); \ + 0; })) +# endif +# endif + +/* These functions needn't check for a bogus signal number -- error + checking is done in the non __ versions. */ + +extern int __sigismember (const __sigset_t *, int); +extern int __sigaddset (__sigset_t *, int); +extern int __sigdelset (__sigset_t *, int); + +# ifdef __USE_EXTERN_INLINES +# define __SIGSETFN(NAME, BODY, CONST) \ + _EXTERN_INLINE int \ + NAME (CONST __sigset_t *__set, int __sig) \ + { \ + unsigned long int __mask = __sigmask (__sig); \ + unsigned long int __word = __sigword (__sig); \ + return BODY; \ + } + +__SIGSETFN (__sigismember, (__set->__val[__word] & __mask) ? 1 : 0, const) +__SIGSETFN (__sigaddset, ((__set->__val[__word] |= __mask), 0), ) +__SIGSETFN (__sigdelset, ((__set->__val[__word] &= ~__mask), 0), ) + +# undef __SIGSETFN +# endif + + +#endif /* ! _SIGSET_H_fns. */ diff --git a/libktorrent/miniboost/bits/sigstack.h b/libktorrent/miniboost/bits/sigstack.h new file mode 100644 index 00000000..e143034c --- /dev/null +++ b/libktorrent/miniboost/bits/sigstack.h @@ -0,0 +1,54 @@ +/* sigstack, sigaltstack definitions. + Copyright (C) 1998-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _SIGNAL_H +# error "Never include this file directly. Use instead" +#endif + + +/* Structure describing a signal stack (obsolete). */ +struct sigstack + { + void *ss_sp; /* Signal stack pointer. */ + int ss_onstack; /* Nonzero if executing on this stack. */ + }; + + +/* Possible values for `ss_flags.'. */ +enum +{ + SS_ONSTACK = 1, +#define SS_ONSTACK SS_ONSTACK + SS_DISABLE +#define SS_DISABLE SS_DISABLE +}; + +/* Minimum stack size for a signal handler. */ +#define MINSIGSTKSZ 2048 + +/* System default stack size. */ +#define SIGSTKSZ 8192 + + +/* Alternate, preferred interface. */ +typedef struct sigaltstack + { + void *ss_sp; + int ss_flags; + size_t ss_size; + } stack_t; diff --git a/libktorrent/miniboost/bits/sigthread.h b/libktorrent/miniboost/bits/sigthread.h new file mode 100644 index 00000000..0048d7fd --- /dev/null +++ b/libktorrent/miniboost/bits/sigthread.h @@ -0,0 +1,43 @@ +/* Signal handling function for threaded programs. + Copyright (C) 1998-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; see the file COPYING.LIB. If + not, see . */ + +#ifndef _BITS_SIGTHREAD_H +#define _BITS_SIGTHREAD_H 1 + +#if !defined _SIGNAL_H && !defined _PTHREAD_H +# error "Never include this file directly. Use instead" +#endif + +/* Functions for handling signals. */ + +/* Modify the signal mask for the calling thread. The arguments have + the same meaning as for sigprocmask(2). */ +extern int pthread_sigmask (int __how, + const __sigset_t *__restrict __newmask, + __sigset_t *__restrict __oldmask)__THROW; + +/* Send signal SIGNO to the given thread. */ +extern int pthread_kill (pthread_t __threadid, int __signo) __THROW; + +#ifdef __USE_GNU +/* Queue signal and data to a thread. */ +extern int pthread_sigqueue (pthread_t __threadid, int __signo, + const union sigval __value) __THROW; +#endif + +#endif /* bits/sigthread.h */ diff --git a/libktorrent/miniboost/bits/stdio-ldbl.h b/libktorrent/miniboost/bits/stdio-ldbl.h new file mode 100644 index 00000000..4cc6c30a --- /dev/null +++ b/libktorrent/miniboost/bits/stdio-ldbl.h @@ -0,0 +1,101 @@ +/* -mlong-double-64 compatibility mode for stdio functions. + Copyright (C) 2006-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDIO_H +# error "Never include directly; use instead." +#endif + +__BEGIN_NAMESPACE_STD +__LDBL_REDIR_DECL (fprintf) +__LDBL_REDIR_DECL (printf) +__LDBL_REDIR_DECL (sprintf) +__LDBL_REDIR_DECL (vfprintf) +__LDBL_REDIR_DECL (vprintf) +__LDBL_REDIR_DECL (vsprintf) +#if defined __USE_ISOC99 && !defined __USE_GNU \ + && !defined __REDIRECT \ + && (defined __STRICT_ANSI__ || defined __USE_XOPEN2K) +__LDBL_REDIR1_DECL (fscanf, __nldbl___isoc99_fscanf) +__LDBL_REDIR1_DECL (scanf, __nldbl___isoc99_scanf) +__LDBL_REDIR1_DECL (sscanf, __nldbl___isoc99_sscanf) +#else +__LDBL_REDIR_DECL (fscanf) +__LDBL_REDIR_DECL (scanf) +__LDBL_REDIR_DECL (sscanf) +#endif +__END_NAMESPACE_STD + +#if defined __USE_ISOC99 || defined __USE_UNIX98 +__BEGIN_NAMESPACE_C99 +__LDBL_REDIR_DECL (snprintf) +__LDBL_REDIR_DECL (vsnprintf) +__END_NAMESPACE_C99 +#endif + +#ifdef __USE_ISOC99 +__BEGIN_NAMESPACE_C99 +# if !defined __USE_GNU && !defined __REDIRECT \ + && (defined __STRICT_ANSI__ || defined __USE_XOPEN2K) +__LDBL_REDIR1_DECL (vfscanf, __nldbl___isoc99_vfscanf) +__LDBL_REDIR1_DECL (vscanf, __nldbl___isoc99_vscanf) +__LDBL_REDIR1_DECL (vsscanf, __nldbl___isoc99_vsscanf) +# else +__LDBL_REDIR_DECL (vfscanf) +__LDBL_REDIR_DECL (vsscanf) +__LDBL_REDIR_DECL (vscanf) +# endif +__END_NAMESPACE_C99 +#endif + +#ifdef __USE_XOPEN2K8 +__LDBL_REDIR_DECL (vdprintf) +__LDBL_REDIR_DECL (dprintf) +#endif + +#ifdef __USE_GNU +__LDBL_REDIR_DECL (vasprintf) +__LDBL_REDIR_DECL (__asprintf) +__LDBL_REDIR_DECL (asprintf) +__LDBL_REDIR_DECL (obstack_printf) +__LDBL_REDIR_DECL (obstack_vprintf) +#endif + +#if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function +__LDBL_REDIR_DECL (__sprintf_chk) +__LDBL_REDIR_DECL (__vsprintf_chk) +# if defined __USE_ISOC99 || defined __USE_UNIX98 +__LDBL_REDIR_DECL (__snprintf_chk) +__LDBL_REDIR_DECL (__vsnprintf_chk) +# endif +# if __USE_FORTIFY_LEVEL > 1 +__LDBL_REDIR_DECL (__fprintf_chk) +__LDBL_REDIR_DECL (__printf_chk) +__LDBL_REDIR_DECL (__vfprintf_chk) +__LDBL_REDIR_DECL (__vprintf_chk) +# ifdef __USE_XOPEN2K8 +__LDBL_REDIR_DECL (__dprintf_chk) +__LDBL_REDIR_DECL (__vdprintf_chk) +# endif +# ifdef __USE_GNU +__LDBL_REDIR_DECL (__asprintf_chk) +__LDBL_REDIR_DECL (__vasprintf_chk) +__LDBL_REDIR_DECL (__obstack_printf_chk) +__LDBL_REDIR_DECL (__obstack_vprintf_chk) +# endif +# endif +#endif diff --git a/libktorrent/miniboost/bits/stdio-lock.h b/libktorrent/miniboost/bits/stdio-lock.h new file mode 100644 index 00000000..e2678cc9 --- /dev/null +++ b/libktorrent/miniboost/bits/stdio-lock.h @@ -0,0 +1,110 @@ +/* Thread package specific definitions of stream lock type. NPTL version. + Copyright (C) 2000-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_STDIO_LOCK_H +#define _BITS_STDIO_LOCK_H 1 + +#include +#include + + +/* The locking here is very inexpensive, even for inlining. */ +#define _IO_lock_inexpensive 1 + +typedef struct { int lock; int cnt; void *owner; } _IO_lock_t; + +#define _IO_lock_initializer { LLL_LOCK_INITIALIZER, 0, NULL } + +#define _IO_lock_init(_name) \ + ((_name) = (_IO_lock_t) _IO_lock_initializer , 0) + +#define _IO_lock_fini(_name) \ + ((void) 0) + +#define _IO_lock_lock(_name) \ + do { \ + void *__self = THREAD_SELF; \ + if ((_name).owner != __self) \ + { \ + lll_lock ((_name).lock, LLL_PRIVATE); \ + (_name).owner = __self; \ + } \ + ++(_name).cnt; \ + } while (0) + +#define _IO_lock_trylock(_name) \ + ({ \ + int __result = 0; \ + void *__self = THREAD_SELF; \ + if ((_name).owner != __self) \ + { \ + if (lll_trylock ((_name).lock) == 0) \ + { \ + (_name).owner = __self; \ + (_name).cnt = 1; \ + } \ + else \ + __result = EBUSY; \ + } \ + else \ + ++(_name).cnt; \ + __result; \ + }) + +#define _IO_lock_unlock(_name) \ + do { \ + if (--(_name).cnt == 0) \ + { \ + (_name).owner = NULL; \ + lll_unlock ((_name).lock, LLL_PRIVATE); \ + } \ + } while (0) + + + +#define _IO_cleanup_region_start(_fct, _fp) \ + __libc_cleanup_region_start (((_fp)->_flags & _IO_USER_LOCK) == 0, _fct, _fp) +#define _IO_cleanup_region_start_noarg(_fct) \ + __libc_cleanup_region_start (1, _fct, NULL) +#define _IO_cleanup_region_end(_doit) \ + __libc_cleanup_region_end (_doit) + +#if defined _LIBC && !defined NOT_IN_libc + +# ifdef __EXCEPTIONS +# define _IO_acquire_lock(_fp) \ + do { \ + _IO_FILE *_IO_acquire_lock_file \ + __attribute__((cleanup (_IO_acquire_lock_fct))) \ + = (_fp); \ + _IO_flockfile (_IO_acquire_lock_file); +# define _IO_acquire_lock_clear_flags2(_fp) \ + do { \ + _IO_FILE *_IO_acquire_lock_file \ + __attribute__((cleanup (_IO_acquire_lock_clear_flags2_fct))) \ + = (_fp); \ + _IO_flockfile (_IO_acquire_lock_file); +# else +# define _IO_acquire_lock(_fp) _IO_acquire_lock_needs_exceptions_enabled +# define _IO_acquire_lock_clear_flags2(_fp) _IO_acquire_lock (_fp) +# endif +# define _IO_release_lock(_fp) ; } while (0) + +#endif + +#endif /* bits/stdio-lock.h */ diff --git a/libktorrent/miniboost/bits/stdio.h b/libktorrent/miniboost/bits/stdio.h new file mode 100644 index 00000000..615ada56 --- /dev/null +++ b/libktorrent/miniboost/bits/stdio.h @@ -0,0 +1,190 @@ +/* Optimizing macros and inline functions for stdio functions. + Copyright (C) 1998-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDIO_H +# error "Never include directly; use instead." +#endif + +#ifndef __extern_inline +# define __STDIO_INLINE inline +#else +# define __STDIO_INLINE __extern_inline +#endif + + +#ifdef __USE_EXTERN_INLINES +/* For -D_FORTIFY_SOURCE{,=2} bits/stdio2.h will define a different + inline. */ +# if !(__USE_FORTIFY_LEVEL > 0 && defined __fortify_function) +/* Write formatted output to stdout from argument list ARG. */ +__STDIO_INLINE int +vprintf (const char *__restrict __fmt, _G_va_list __arg) +{ + return vfprintf (stdout, __fmt, __arg); +} +# endif + +/* Read a character from stdin. */ +__STDIO_INLINE int +getchar (void) +{ + return _IO_getc (stdin); +} + + +# ifdef __USE_MISC +/* Faster version when locking is not necessary. */ +__STDIO_INLINE int +fgetc_unlocked (FILE *__fp) +{ + return _IO_getc_unlocked (__fp); +} +# endif /* misc */ + + +# ifdef __USE_POSIX +/* This is defined in POSIX.1:1996. */ +__STDIO_INLINE int +getc_unlocked (FILE *__fp) +{ + return _IO_getc_unlocked (__fp); +} + +/* This is defined in POSIX.1:1996. */ +__STDIO_INLINE int +getchar_unlocked (void) +{ + return _IO_getc_unlocked (stdin); +} +# endif /* POSIX */ + + +/* Write a character to stdout. */ +__STDIO_INLINE int +putchar (int __c) +{ + return _IO_putc (__c, stdout); +} + + +# ifdef __USE_MISC +/* Faster version when locking is not necessary. */ +__STDIO_INLINE int +fputc_unlocked (int __c, FILE *__stream) +{ + return _IO_putc_unlocked (__c, __stream); +} +# endif /* misc */ + + +# ifdef __USE_POSIX +/* This is defined in POSIX.1:1996. */ +__STDIO_INLINE int +putc_unlocked (int __c, FILE *__stream) +{ + return _IO_putc_unlocked (__c, __stream); +} + +/* This is defined in POSIX.1:1996. */ +__STDIO_INLINE int +putchar_unlocked (int __c) +{ + return _IO_putc_unlocked (__c, stdout); +} +# endif /* POSIX */ + + +# ifdef __USE_GNU +/* Like `getdelim', but reads up to a newline. */ +__STDIO_INLINE _IO_ssize_t +getline (char **__lineptr, size_t *__n, FILE *__stream) +{ + return __getdelim (__lineptr, __n, '\n', __stream); +} +# endif /* GNU */ + + +# ifdef __USE_MISC +/* Faster versions when locking is not required. */ +__STDIO_INLINE int +__NTH (feof_unlocked (FILE *__stream)) +{ + return _IO_feof_unlocked (__stream); +} + +/* Faster versions when locking is not required. */ +__STDIO_INLINE int +__NTH (ferror_unlocked (FILE *__stream)) +{ + return _IO_ferror_unlocked (__stream); +} +# endif /* misc */ + +#endif /* Use extern inlines. */ + + +#if defined __USE_MISC && defined __GNUC__ && defined __OPTIMIZE__ \ + && !defined __cplusplus +/* Perform some simple optimizations. */ +# define fread_unlocked(ptr, size, n, stream) \ + (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) \ + && (size_t) (size) * (size_t) (n) <= 8 \ + && (size_t) (size) != 0) \ + ? ({ char *__ptr = (char *) (ptr); \ + FILE *__stream = (stream); \ + size_t __cnt; \ + for (__cnt = (size_t) (size) * (size_t) (n); \ + __cnt > 0; --__cnt) \ + { \ + int __c = _IO_getc_unlocked (__stream); \ + if (__c == EOF) \ + break; \ + *__ptr++ = __c; \ + } \ + ((size_t) (size) * (size_t) (n) - __cnt) \ + / (size_t) (size); }) \ + : (((__builtin_constant_p (size) && (size_t) (size) == 0) \ + || (__builtin_constant_p (n) && (size_t) (n) == 0)) \ + /* Evaluate all parameters once. */ \ + ? ((void) (ptr), (void) (stream), (void) (size), \ + (void) (n), (size_t) 0) \ + : fread_unlocked (ptr, size, n, stream)))) + +# define fwrite_unlocked(ptr, size, n, stream) \ + (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) \ + && (size_t) (size) * (size_t) (n) <= 8 \ + && (size_t) (size) != 0) \ + ? ({ const char *__ptr = (const char *) (ptr); \ + FILE *__stream = (stream); \ + size_t __cnt; \ + for (__cnt = (size_t) (size) * (size_t) (n); \ + __cnt > 0; --__cnt) \ + if (_IO_putc_unlocked (*__ptr++, __stream) == EOF) \ + break; \ + ((size_t) (size) * (size_t) (n) - __cnt) \ + / (size_t) (size); }) \ + : (((__builtin_constant_p (size) && (size_t) (size) == 0) \ + || (__builtin_constant_p (n) && (size_t) (n) == 0)) \ + /* Evaluate all parameters once. */ \ + ? ((void) (ptr), (void) (stream), (void) (size), \ + (void) (n), (size_t) 0) \ + : fwrite_unlocked (ptr, size, n, stream)))) +#endif + +/* Define helper macro. */ +#undef __STDIO_INLINE diff --git a/libktorrent/miniboost/bits/stdio2.h b/libktorrent/miniboost/bits/stdio2.h new file mode 100644 index 00000000..7cb6e51b --- /dev/null +++ b/libktorrent/miniboost/bits/stdio2.h @@ -0,0 +1,382 @@ +/* Checking macros for stdio functions. + Copyright (C) 2004-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDIO_H +# error "Never include directly; use instead." +#endif + +extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen, + const char *__restrict __format, ...) __THROW; +extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen, + const char *__restrict __format, + _G_va_list __ap) __THROW; + +#ifdef __va_arg_pack +__fortify_function int +__NTH (sprintf (char *__restrict __s, const char *__restrict __fmt, ...)) +{ + return __builtin___sprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, + __bos (__s), __fmt, __va_arg_pack ()); +} +#elif !defined __cplusplus +# define sprintf(str, ...) \ + __builtin___sprintf_chk (str, __USE_FORTIFY_LEVEL - 1, __bos (str), \ + __VA_ARGS__) +#endif + +__fortify_function int +__NTH (vsprintf (char *__restrict __s, const char *__restrict __fmt, + _G_va_list __ap)) +{ + return __builtin___vsprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, + __bos (__s), __fmt, __ap); +} + +#if defined __USE_ISOC99 || defined __USE_UNIX98 + +extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag, + size_t __slen, const char *__restrict __format, + ...) __THROW; +extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag, + size_t __slen, const char *__restrict __format, + _G_va_list __ap) __THROW; + +# ifdef __va_arg_pack +__fortify_function int +__NTH (snprintf (char *__restrict __s, size_t __n, + const char *__restrict __fmt, ...)) +{ + return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, + __bos (__s), __fmt, __va_arg_pack ()); +} +# elif !defined __cplusplus +# define snprintf(str, len, ...) \ + __builtin___snprintf_chk (str, len, __USE_FORTIFY_LEVEL - 1, __bos (str), \ + __VA_ARGS__) +# endif + +__fortify_function int +__NTH (vsnprintf (char *__restrict __s, size_t __n, + const char *__restrict __fmt, _G_va_list __ap)) +{ + return __builtin___vsnprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, + __bos (__s), __fmt, __ap); +} + +#endif + +#if __USE_FORTIFY_LEVEL > 1 + +extern int __fprintf_chk (FILE *__restrict __stream, int __flag, + const char *__restrict __format, ...); +extern int __printf_chk (int __flag, const char *__restrict __format, ...); +extern int __vfprintf_chk (FILE *__restrict __stream, int __flag, + const char *__restrict __format, _G_va_list __ap); +extern int __vprintf_chk (int __flag, const char *__restrict __format, + _G_va_list __ap); + +# ifdef __va_arg_pack +__fortify_function int +fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...) +{ + return __fprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, + __va_arg_pack ()); +} + +__fortify_function int +printf (const char *__restrict __fmt, ...) +{ + return __printf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); +} +# elif !defined __cplusplus +# define printf(...) \ + __printf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# define fprintf(stream, ...) \ + __fprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# endif + +__fortify_function int +vprintf (const char *__restrict __fmt, _G_va_list __ap) +{ +#ifdef __USE_EXTERN_INLINES + return __vfprintf_chk (stdout, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +#else + return __vprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); +#endif +} + +__fortify_function int +vfprintf (FILE *__restrict __stream, + const char *__restrict __fmt, _G_va_list __ap) +{ + return __vfprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +} + +# ifdef __USE_XOPEN2K8 +extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt, + ...) __attribute__ ((__format__ (__printf__, 3, 4))); +extern int __vdprintf_chk (int __fd, int __flag, + const char *__restrict __fmt, _G_va_list __arg) + __attribute__ ((__format__ (__printf__, 3, 0))); + +# ifdef __va_arg_pack +__fortify_function int +dprintf (int __fd, const char *__restrict __fmt, ...) +{ + return __dprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, + __va_arg_pack ()); +} +# elif !defined __cplusplus +# define dprintf(fd, ...) \ + __dprintf_chk (fd, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# endif + +__fortify_function int +vdprintf (int __fd, const char *__restrict __fmt, _G_va_list __ap) +{ + return __vdprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +} +# endif + +# ifdef __USE_GNU + +extern int __asprintf_chk (char **__restrict __ptr, int __flag, + const char *__restrict __fmt, ...) + __THROW __attribute__ ((__format__ (__printf__, 3, 4))) __wur; +extern int __vasprintf_chk (char **__restrict __ptr, int __flag, + const char *__restrict __fmt, _G_va_list __arg) + __THROW __attribute__ ((__format__ (__printf__, 3, 0))) __wur; +extern int __obstack_printf_chk (struct obstack *__restrict __obstack, + int __flag, const char *__restrict __format, + ...) + __THROW __attribute__ ((__format__ (__printf__, 3, 4))); +extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack, + int __flag, + const char *__restrict __format, + _G_va_list __args) + __THROW __attribute__ ((__format__ (__printf__, 3, 0))); + +# ifdef __va_arg_pack +__fortify_function int +__NTH (asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)) +{ + return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, + __va_arg_pack ()); +} + +__fortify_function int +__NTH (__asprintf (char **__restrict __ptr, const char *__restrict __fmt, + ...)) +{ + return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, + __va_arg_pack ()); +} + +__fortify_function int +__NTH (obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __fmt, ...)) +{ + return __obstack_printf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, + __va_arg_pack ()); +} +# elif !defined __cplusplus +# define asprintf(ptr, ...) \ + __asprintf_chk (ptr, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# define __asprintf(ptr, ...) \ + __asprintf_chk (ptr, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# define obstack_printf(obstack, ...) \ + __obstack_printf_chk (obstack, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# endif + +__fortify_function int +__NTH (vasprintf (char **__restrict __ptr, const char *__restrict __fmt, + _G_va_list __ap)) +{ + return __vasprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +} + +__fortify_function int +__NTH (obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __fmt, _G_va_list __ap)) +{ + return __obstack_vprintf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, + __ap); +} + +# endif + +#endif + +#if !defined __USE_ISOC11 \ + || (defined __cplusplus && __cplusplus <= 201103L && !defined __USE_GNU) +extern char *__gets_chk (char *__str, size_t) __wur; +extern char *__REDIRECT (__gets_warn, (char *__str), gets) + __wur __warnattr ("please use fgets or getline instead, gets can't " + "specify buffer size"); + +__fortify_function __wur char * +gets (char *__str) +{ + if (__bos (__str) != (size_t) -1) + return __gets_chk (__str, __bos (__str)); + return __gets_warn (__str); +} +#endif + +extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, + FILE *__restrict __stream) __wur; +extern char *__REDIRECT (__fgets_alias, + (char *__restrict __s, int __n, + FILE *__restrict __stream), fgets) __wur; +extern char *__REDIRECT (__fgets_chk_warn, + (char *__restrict __s, size_t __size, int __n, + FILE *__restrict __stream), __fgets_chk) + __wur __warnattr ("fgets called with bigger size than length " + "of destination buffer"); + +__fortify_function __wur char * +fgets (char *__restrict __s, int __n, FILE *__restrict __stream) +{ + if (__bos (__s) != (size_t) -1) + { + if (!__builtin_constant_p (__n) || __n <= 0) + return __fgets_chk (__s, __bos (__s), __n, __stream); + + if ((size_t) __n > __bos (__s)) + return __fgets_chk_warn (__s, __bos (__s), __n, __stream); + } + return __fgets_alias (__s, __n, __stream); +} + +extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, + size_t __size, size_t __n, + FILE *__restrict __stream) __wur; +extern size_t __REDIRECT (__fread_alias, + (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream), + fread) __wur; +extern size_t __REDIRECT (__fread_chk_warn, + (void *__restrict __ptr, size_t __ptrlen, + size_t __size, size_t __n, + FILE *__restrict __stream), + __fread_chk) + __wur __warnattr ("fread called with bigger size * nmemb than length " + "of destination buffer"); + +__fortify_function __wur size_t +fread (void *__restrict __ptr, size_t __size, size_t __n, + FILE *__restrict __stream) +{ + if (__bos0 (__ptr) != (size_t) -1) + { + if (!__builtin_constant_p (__size) + || !__builtin_constant_p (__n) + || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2))) + return __fread_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); + + if (__size * __n > __bos0 (__ptr)) + return __fread_chk_warn (__ptr, __bos0 (__ptr), __size, __n, __stream); + } + return __fread_alias (__ptr, __size, __n, __stream); +} + +#ifdef __USE_GNU +extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size, + int __n, FILE *__restrict __stream) __wur; +extern char *__REDIRECT (__fgets_unlocked_alias, + (char *__restrict __s, int __n, + FILE *__restrict __stream), fgets_unlocked) __wur; +extern char *__REDIRECT (__fgets_unlocked_chk_warn, + (char *__restrict __s, size_t __size, int __n, + FILE *__restrict __stream), __fgets_unlocked_chk) + __wur __warnattr ("fgets_unlocked called with bigger size than length " + "of destination buffer"); + +__fortify_function __wur char * +fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) +{ + if (__bos (__s) != (size_t) -1) + { + if (!__builtin_constant_p (__n) || __n <= 0) + return __fgets_unlocked_chk (__s, __bos (__s), __n, __stream); + + if ((size_t) __n > __bos (__s)) + return __fgets_unlocked_chk_warn (__s, __bos (__s), __n, __stream); + } + return __fgets_unlocked_alias (__s, __n, __stream); +} +#endif + +#ifdef __USE_MISC +# undef fread_unlocked +extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen, + size_t __size, size_t __n, + FILE *__restrict __stream) __wur; +extern size_t __REDIRECT (__fread_unlocked_alias, + (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream), + fread_unlocked) __wur; +extern size_t __REDIRECT (__fread_unlocked_chk_warn, + (void *__restrict __ptr, size_t __ptrlen, + size_t __size, size_t __n, + FILE *__restrict __stream), + __fread_unlocked_chk) + __wur __warnattr ("fread_unlocked called with bigger size * nmemb than " + "length of destination buffer"); + +__fortify_function __wur size_t +fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, + FILE *__restrict __stream) +{ + if (__bos0 (__ptr) != (size_t) -1) + { + if (!__builtin_constant_p (__size) + || !__builtin_constant_p (__n) + || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2))) + return __fread_unlocked_chk (__ptr, __bos0 (__ptr), __size, __n, + __stream); + + if (__size * __n > __bos0 (__ptr)) + return __fread_unlocked_chk_warn (__ptr, __bos0 (__ptr), __size, __n, + __stream); + } + +# ifdef __USE_EXTERN_INLINES + if (__builtin_constant_p (__size) + && __builtin_constant_p (__n) + && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2)) + && __size * __n <= 8) + { + size_t __cnt = __size * __n; + char *__cptr = (char *) __ptr; + if (__cnt == 0) + return 0; + + for (; __cnt > 0; --__cnt) + { + int __c = _IO_getc_unlocked (__stream); + if (__c == EOF) + break; + *__cptr++ = __c; + } + return (__cptr - (char *) __ptr) / __size; + } +# endif + return __fread_unlocked_alias (__ptr, __size, __n, __stream); +} +#endif diff --git a/libktorrent/miniboost/bits/stdio_lim.h b/libktorrent/miniboost/bits/stdio_lim.h new file mode 100644 index 00000000..58019f7c --- /dev/null +++ b/libktorrent/miniboost/bits/stdio_lim.h @@ -0,0 +1,42 @@ +/* Copyright (C) 1994-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#if !defined _STDIO_H && !defined __need_FOPEN_MAX && !defined __need_IOV_MAX +# error "Never include directly; use instead." +#endif + +#ifdef _STDIO_H +# define L_tmpnam 20 +# define TMP_MAX 238328 +# define FILENAME_MAX 4096 + +# ifdef __USE_POSIX +# define L_ctermid 9 +# if !defined __USE_XOPEN2K || defined __USE_GNU +# define L_cuserid 9 +# endif +# endif +#endif + +#if defined __need_FOPEN_MAX || defined _STDIO_H +# undef FOPEN_MAX +# define FOPEN_MAX 16 +#endif + +#if defined __need_IOV_MAX && !defined IOV_MAX +# define IOV_MAX 1024 +#endif diff --git a/libktorrent/miniboost/bits/stdlib-bsearch.h b/libktorrent/miniboost/bits/stdlib-bsearch.h new file mode 100644 index 00000000..78b44464 --- /dev/null +++ b/libktorrent/miniboost/bits/stdlib-bsearch.h @@ -0,0 +1,43 @@ +/* Perform binary search - inline version. + Copyright (C) 1991-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +__extern_inline void * +bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) +{ + size_t __l, __u, __idx; + const void *__p; + int __comparison; + + __l = 0; + __u = __nmemb; + while (__l < __u) + { + __idx = (__l + __u) / 2; + __p = (void *) (((const char *) __base) + (__idx * __size)); + __comparison = (*__compar) (__key, __p); + if (__comparison < 0) + __u = __idx; + else if (__comparison > 0) + __l = __idx + 1; + else + return (void *) __p; + } + + return NULL; +} diff --git a/libktorrent/miniboost/bits/stdlib-float.h b/libktorrent/miniboost/bits/stdlib-float.h new file mode 100644 index 00000000..fdee2d53 --- /dev/null +++ b/libktorrent/miniboost/bits/stdlib-float.h @@ -0,0 +1,31 @@ +/* Floating-point inline functions for stdlib.h. + Copyright (C) 2012-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDLIB_H +# error "Never use directly; include instead." +#endif + +#ifdef __USE_EXTERN_INLINES +__BEGIN_NAMESPACE_STD +__extern_inline double +__NTH (atof (const char *__nptr)) +{ + return strtod (__nptr, (char **) NULL); +} +__END_NAMESPACE_STD +#endif /* Optimizing and Inlining. */ diff --git a/libktorrent/miniboost/bits/stdlib-ldbl.h b/libktorrent/miniboost/bits/stdlib-ldbl.h new file mode 100644 index 00000000..feadbdf3 --- /dev/null +++ b/libktorrent/miniboost/bits/stdlib-ldbl.h @@ -0,0 +1,39 @@ +/* -mlong-double-64 compatibility mode for functions. + Copyright (C) 2006-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDLIB_H +# error "Never include directly; use instead." +#endif + +#ifdef __USE_ISOC99 +__BEGIN_NAMESPACE_C99 +__LDBL_REDIR1_DECL (strtold, strtod) +__END_NAMESPACE_C99 +#endif + +#ifdef __USE_GNU +__LDBL_REDIR1_DECL (strtold_l, strtod_l) +#endif + +#ifdef __USE_MISC +__LDBL_REDIR1_DECL (qecvt, ecvt) +__LDBL_REDIR1_DECL (qfcvt, fcvt) +__LDBL_REDIR1_DECL (qgcvt, gcvt) +__LDBL_REDIR1_DECL (qecvt_r, ecvt_r) +__LDBL_REDIR1_DECL (qfcvt_r, fcvt_r) +#endif diff --git a/libktorrent/miniboost/bits/stdlib.h b/libktorrent/miniboost/bits/stdlib.h new file mode 100644 index 00000000..7b5b57b5 --- /dev/null +++ b/libktorrent/miniboost/bits/stdlib.h @@ -0,0 +1,155 @@ +/* Checking macros for stdlib functions. + Copyright (C) 2005-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDLIB_H +# error "Never include directly; use instead." +#endif + +extern char *__realpath_chk (const char *__restrict __name, + char *__restrict __resolved, + size_t __resolvedlen) __THROW __wur; +extern char *__REDIRECT_NTH (__realpath_alias, + (const char *__restrict __name, + char *__restrict __resolved), realpath) __wur; +extern char *__REDIRECT_NTH (__realpath_chk_warn, + (const char *__restrict __name, + char *__restrict __resolved, + size_t __resolvedlen), __realpath_chk) __wur + __warnattr ("second argument of realpath must be either NULL or at " + "least PATH_MAX bytes long buffer"); + +__fortify_function __wur char * +__NTH (realpath (const char *__restrict __name, char *__restrict __resolved)) +{ + if (__bos (__resolved) != (size_t) -1) + { +#if defined _LIBC_LIMITS_H_ && defined PATH_MAX + if (__bos (__resolved) < PATH_MAX) + return __realpath_chk_warn (__name, __resolved, __bos (__resolved)); +#endif + return __realpath_chk (__name, __resolved, __bos (__resolved)); + } + + return __realpath_alias (__name, __resolved); +} + + +extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, + size_t __nreal) __THROW __nonnull ((2)); +extern int __REDIRECT_NTH (__ptsname_r_alias, (int __fd, char *__buf, + size_t __buflen), ptsname_r) + __nonnull ((2)); +extern int __REDIRECT_NTH (__ptsname_r_chk_warn, + (int __fd, char *__buf, size_t __buflen, + size_t __nreal), __ptsname_r_chk) + __nonnull ((2)) __warnattr ("ptsname_r called with buflen bigger than " + "size of buf"); + +__fortify_function int +__NTH (ptsname_r (int __fd, char *__buf, size_t __buflen)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__buflen)) + return __ptsname_r_chk (__fd, __buf, __buflen, __bos (__buf)); + if (__buflen > __bos (__buf)) + return __ptsname_r_chk_warn (__fd, __buf, __buflen, __bos (__buf)); + } + return __ptsname_r_alias (__fd, __buf, __buflen); +} + + +extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen) + __THROW __wur; +extern int __REDIRECT_NTH (__wctomb_alias, (char *__s, wchar_t __wchar), + wctomb) __wur; + +__fortify_function __wur int +__NTH (wctomb (char *__s, wchar_t __wchar)) +{ + /* We would have to include to get a definition of MB_LEN_MAX. + But this would only disturb the namespace. So we define our own + version here. */ +#define __STDLIB_MB_LEN_MAX 16 +#if defined MB_LEN_MAX && MB_LEN_MAX != __STDLIB_MB_LEN_MAX +# error "Assumed value of MB_LEN_MAX wrong" +#endif + if (__bos (__s) != (size_t) -1 && __STDLIB_MB_LEN_MAX > __bos (__s)) + return __wctomb_chk (__s, __wchar, __bos (__s)); + return __wctomb_alias (__s, __wchar); +} + + +extern size_t __mbstowcs_chk (wchar_t *__restrict __dst, + const char *__restrict __src, + size_t __len, size_t __dstlen) __THROW; +extern size_t __REDIRECT_NTH (__mbstowcs_alias, + (wchar_t *__restrict __dst, + const char *__restrict __src, + size_t __len), mbstowcs); +extern size_t __REDIRECT_NTH (__mbstowcs_chk_warn, + (wchar_t *__restrict __dst, + const char *__restrict __src, + size_t __len, size_t __dstlen), __mbstowcs_chk) + __warnattr ("mbstowcs called with dst buffer smaller than len " + "* sizeof (wchar_t)"); + +__fortify_function size_t +__NTH (mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, + size_t __len)) +{ + if (__bos (__dst) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __mbstowcs_chk (__dst, __src, __len, + __bos (__dst) / sizeof (wchar_t)); + + if (__len > __bos (__dst) / sizeof (wchar_t)) + return __mbstowcs_chk_warn (__dst, __src, __len, + __bos (__dst) / sizeof (wchar_t)); + } + return __mbstowcs_alias (__dst, __src, __len); +} + + +extern size_t __wcstombs_chk (char *__restrict __dst, + const wchar_t *__restrict __src, + size_t __len, size_t __dstlen) __THROW; +extern size_t __REDIRECT_NTH (__wcstombs_alias, + (char *__restrict __dst, + const wchar_t *__restrict __src, + size_t __len), wcstombs); +extern size_t __REDIRECT_NTH (__wcstombs_chk_warn, + (char *__restrict __dst, + const wchar_t *__restrict __src, + size_t __len, size_t __dstlen), __wcstombs_chk) + __warnattr ("wcstombs called with dst buffer smaller than len"); + +__fortify_function size_t +__NTH (wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, + size_t __len)) +{ + if (__bos (__dst) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __wcstombs_chk (__dst, __src, __len, __bos (__dst)); + if (__len > __bos (__dst)) + return __wcstombs_chk_warn (__dst, __src, __len, __bos (__dst)); + } + return __wcstombs_alias (__dst, __src, __len); +} diff --git a/libktorrent/miniboost/bits/string.h b/libktorrent/miniboost/bits/string.h new file mode 100644 index 00000000..423ad388 --- /dev/null +++ b/libktorrent/miniboost/bits/string.h @@ -0,0 +1,1985 @@ +/* Optimized, inlined string functions. i486/x86-64 version. + Copyright (C) 2001-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STRING_H +# error "Never use directly; include instead." +#endif + +/* The ix86 processors can access unaligned multi-byte variables. */ +#define _STRING_ARCH_unaligned 1 + +/* Enable inline functions only for i486 or better when compiling for + ia32. */ +#if !defined __x86_64__ && (defined __i486__ || defined __pentium__ \ + || defined __pentiumpro__ || defined __pentium4__ \ + || defined __nocona__ || defined __atom__ \ + || defined __core2__ || defined __corei7__ \ + || defined __k6__ || defined __geode__ \ + || defined __k8__ || defined __athlon__ \ + || defined __amdfam10__) + +/* We only provide optimizations if the user selects them and if + GNU CC is used. */ +# if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \ + && defined __GNUC__ && __GNUC__ >= 2 + +# ifndef __STRING_INLINE +# ifndef __extern_inline +# define __STRING_INLINE inline +# else +# define __STRING_INLINE __extern_inline +# endif +# endif + +/* The macros are used in some of the optimized implementations below. */ +# define __STRING_SMALL_GET16(src, idx) \ + ((((const unsigned char *) (src))[idx + 1] << 8) \ + | ((const unsigned char *) (src))[idx]) +# define __STRING_SMALL_GET32(src, idx) \ + (((((const unsigned char *) (src))[idx + 3] << 8 \ + | ((const unsigned char *) (src))[idx + 2]) << 8 \ + | ((const unsigned char *) (src))[idx + 1]) << 8 \ + | ((const unsigned char *) (src))[idx]) + + +/* Copy N bytes of SRC to DEST. */ +# define _HAVE_STRING_ARCH_memcpy 1 +# define memcpy(dest, src, n) \ + (__extension__ (__builtin_constant_p (n) \ + ? __memcpy_c ((dest), (src), (n)) \ + : __memcpy_g ((dest), (src), (n)))) +# define __memcpy_c(dest, src, n) \ + ((n) == 0 \ + ? (dest) \ + : (((n) % 4 == 0) \ + ? __memcpy_by4 (dest, src, n) \ + : (((n) % 2 == 0) \ + ? __memcpy_by2 (dest, src, n) \ + : __memcpy_g (dest, src, n)))) + +__STRING_INLINE void *__memcpy_by4 (void *__dest, const void *__src, + size_t __n); + +__STRING_INLINE void * +__memcpy_by4 (void *__dest, const void *__src, size_t __n) +{ + register unsigned long int __d0, __d1; + register void *__tmp = __dest; + __asm__ __volatile__ + ("1:\n\t" + "movl (%2),%0\n\t" + "leal 4(%2),%2\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %3\n\t" + "jnz 1b" + : "=&r" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1) + : "1" (__tmp), "2" (__src), "3" (__n / 4) + : "memory", "cc"); + return __dest; +} + +__STRING_INLINE void *__memcpy_by2 (void *__dest, const void *__src, + size_t __n); + +__STRING_INLINE void * +__memcpy_by2 (void *__dest, const void *__src, size_t __n) +{ + register unsigned long int __d0, __d1; + register void *__tmp = __dest; + __asm__ __volatile__ + ("shrl $1,%3\n\t" + "jz 2f\n" /* only a word */ + "1:\n\t" + "movl (%2),%0\n\t" + "leal 4(%2),%2\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %3\n\t" + "jnz 1b\n" + "2:\n\t" + "movw (%2),%w0\n\t" + "movw %w0,(%1)" + : "=&q" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1) + : "1" (__tmp), "2" (__src), "3" (__n / 2) + : "memory", "cc"); + return __dest; +} + +__STRING_INLINE void *__memcpy_g (void *__dest, const void *__src, size_t __n); + +__STRING_INLINE void * +__memcpy_g (void *__dest, const void *__src, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + register void *__tmp = __dest; + __asm__ __volatile__ + ("cld\n\t" + "shrl $1,%%ecx\n\t" + "jnc 1f\n\t" + "movsb\n" + "1:\n\t" + "shrl $1,%%ecx\n\t" + "jnc 2f\n\t" + "movsw\n" + "2:\n\t" + "rep; movsl" + : "=&c" (__d0), "=&D" (__d1), "=&S" (__d2), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest) + : "0" (__n), "1" (__tmp), "2" (__src), + "m" ( *(struct { __extension__ char __x[__n]; } *)__src) + : "cc"); + return __dest; +} + +# define _HAVE_STRING_ARCH_memmove 1 +# ifndef _FORCE_INLINES +/* Copy N bytes of SRC to DEST, guaranteeing + correct behavior for overlapping strings. */ +# define memmove(dest, src, n) __memmove_g (dest, src, n) + +__STRING_INLINE void *__memmove_g (void *, const void *, size_t) + __asm__ ("memmove"); + +__STRING_INLINE void * +__memmove_g (void *__dest, const void *__src, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + register void *__tmp = __dest; + if (__dest < __src) + __asm__ __volatile__ + ("cld\n\t" + "rep; movsb" + : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest) + : "0" (__n), "1" (__src), "2" (__tmp), + "m" ( *(struct { __extension__ char __x[__n]; } *)__src)); + else + __asm__ __volatile__ + ("std\n\t" + "rep; movsb\n\t" + "cld" + : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest) + : "0" (__n), "1" (__n - 1 + (const char *) __src), + "2" (__n - 1 + (char *) __tmp), + "m" ( *(struct { __extension__ char __x[__n]; } *)__src)); + return __dest; +} +# endif + +/* Compare N bytes of S1 and S2. */ +# define _HAVE_STRING_ARCH_memcmp 1 +# ifndef _FORCE_INLINES +# ifndef __PIC__ +/* gcc has problems to spill registers when using PIC. */ +__STRING_INLINE int +memcmp (const void *__s1, const void *__s2, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + register int __res; + __asm__ __volatile__ + ("cld\n\t" + "testl %3,%3\n\t" + "repe; cmpsb\n\t" + "je 1f\n\t" + "sbbl %0,%0\n\t" + "orl $1,%0\n" + "1:" + : "=&a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2) + : "0" (0), "1" (__s1), "2" (__s2), "3" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s1), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s2) + : "cc"); + return __res; +} +# endif +# endif + +/* Set N bytes of S to C. */ +# define _HAVE_STRING_ARCH_memset 1 +# define _USE_STRING_ARCH_memset 1 +# define memset(s, c, n) \ + (__extension__ (__builtin_constant_p (n) && (n) <= 16 \ + ? ((n) == 1 \ + ? __memset_c1 ((s), (c)) \ + : __memset_gc ((s), (c), (n))) \ + : (__builtin_constant_p (c) \ + ? (__builtin_constant_p (n) \ + ? __memset_ccn ((s), (c), (n)) \ + : memset ((s), (c), (n))) \ + : (__builtin_constant_p (n) \ + ? __memset_gcn ((s), (c), (n)) \ + : memset ((s), (c), (n)))))) + +# define __memset_c1(s, c) ({ void *__s = (s); \ + *((unsigned char *) __s) = (unsigned char) (c); \ + __s; }) + +# define __memset_gc(s, c, n) \ + ({ void *__s = (s); \ + union { \ + unsigned int __ui; \ + unsigned short int __usi; \ + unsigned char __uc; \ + } *__u = __s; \ + unsigned int __c = ((unsigned int) ((unsigned char) (c))) * 0x01010101; \ + \ + /* We apply a trick here. `gcc' would implement the following \ + assignments using immediate operands. But this uses to much \ + memory (7, instead of 4 bytes). So we force the value in a \ + registers. */ \ + if ((n) == 3 || (n) >= 5) \ + __asm__ __volatile__ ("" : "=r" (__c) : "0" (__c)); \ + \ + /* This `switch' statement will be removed at compile-time. */ \ + switch (n) \ + { \ + case 15: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 11: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 7: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 3: \ + __u->__usi = (unsigned short int) __c; \ + __u = __extension__ ((void *) __u + 2); \ + __u->__uc = (unsigned char) __c; \ + break; \ + \ + case 14: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 10: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 6: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 2: \ + __u->__usi = (unsigned short int) __c; \ + break; \ + \ + case 13: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 9: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 5: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 1: \ + __u->__uc = (unsigned char) __c; \ + break; \ + \ + case 16: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 12: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 8: \ + __u->__ui = __c; \ + __u = __extension__ ((void *) __u + 4); \ + case 4: \ + __u->__ui = __c; \ + case 0: \ + break; \ + } \ + \ + __s; }) + +# define __memset_ccn(s, c, n) \ + (((n) % 4 == 0) \ + ? __memset_ccn_by4 (s, ((unsigned int) ((unsigned char) (c))) * 0x01010101,\ + n) \ + : (((n) % 2 == 0) \ + ? __memset_ccn_by2 (s, \ + ((unsigned int) ((unsigned char) (c))) * 0x01010101,\ + n) \ + : memset (s, c, n))) + +__STRING_INLINE void *__memset_ccn_by4 (void *__s, unsigned int __c, + size_t __n); + +__STRING_INLINE void * +__memset_ccn_by4 (void *__s, unsigned int __c, size_t __n) +{ + register void *__tmp = __s; + register unsigned long int __d0; +# ifdef __i686__ + __asm__ __volatile__ + ("cld\n\t" + "rep; stosl" + : "=&a" (__c), "=&D" (__tmp), "=&c" (__d0), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4) + : "cc"); +# else + __asm__ __volatile__ + ("1:\n\t" + "movl %0,(%1)\n\t" + "addl $4,%1\n\t" + "decl %2\n\t" + "jnz 1b\n" + : "=&r" (__c), "=&r" (__tmp), "=&r" (__d0), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4) + : "cc"); +# endif + return __s; +} + +__STRING_INLINE void *__memset_ccn_by2 (void *__s, unsigned int __c, + size_t __n); + +__STRING_INLINE void * +__memset_ccn_by2 (void *__s, unsigned int __c, size_t __n) +{ + register unsigned long int __d0, __d1; + register void *__tmp = __s; +# ifdef __i686__ + __asm__ __volatile__ + ("cld\n\t" + "rep; stosl\n" + "stosw" + : "=&a" (__d0), "=&D" (__tmp), "=&c" (__d1), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4) + : "cc"); +# else + __asm__ __volatile__ + ("1:\tmovl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %2\n\t" + "jnz 1b\n" + "movw %w0,(%1)" + : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4) + : "cc"); +#endif + return __s; +} + +# define __memset_gcn(s, c, n) \ + (((n) % 4 == 0) \ + ? __memset_gcn_by4 (s, c, n) \ + : (((n) % 2 == 0) \ + ? __memset_gcn_by2 (s, c, n) \ + : memset (s, c, n))) + +__STRING_INLINE void *__memset_gcn_by4 (void *__s, int __c, size_t __n); + +__STRING_INLINE void * +__memset_gcn_by4 (void *__s, int __c, size_t __n) +{ + register void *__tmp = __s; + register unsigned long int __d0; + __asm__ __volatile__ + ("movb %b0,%h0\n" + "pushw %w0\n\t" + "shll $16,%0\n\t" + "popw %w0\n" + "1:\n\t" + "movl %0,(%1)\n\t" + "addl $4,%1\n\t" + "decl %2\n\t" + "jnz 1b\n" + : "=&q" (__c), "=&r" (__tmp), "=&r" (__d0), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4) + : "cc"); + return __s; +} + +__STRING_INLINE void *__memset_gcn_by2 (void *__s, int __c, size_t __n); + +__STRING_INLINE void * +__memset_gcn_by2 (void *__s, int __c, size_t __n) +{ + register unsigned long int __d0, __d1; + register void *__tmp = __s; + __asm__ __volatile__ + ("movb %b0,%h0\n\t" + "pushw %w0\n\t" + "shll $16,%0\n\t" + "popw %w0\n" + "1:\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %2\n\t" + "jnz 1b\n" + "movw %w0,(%1)" + : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1), + "=m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4) + : "cc"); + return __s; +} + + +/* Search N bytes of S for C. */ +# define _HAVE_STRING_ARCH_memchr 1 +# ifndef _FORCE_INLINES +__STRING_INLINE void * +memchr (const void *__s, int __c, size_t __n) +{ + register unsigned long int __d0; +# ifdef __i686__ + register unsigned long int __d1; +# endif + register unsigned char *__res; + if (__n == 0) + return NULL; +# ifdef __i686__ + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "cmovne %2,%0" + : "=D" (__res), "=&c" (__d0), "=&r" (__d1) + : "a" (__c), "0" (__s), "1" (__n), "2" (1), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "cc"); +# else + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "je 1f\n\t" + "movl $1,%0\n" + "1:" + : "=D" (__res), "=&c" (__d0) + : "a" (__c), "0" (__s), "1" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "cc"); +# endif + return __res - 1; +} +# endif + +# define _HAVE_STRING_ARCH_memrchr 1 +# ifndef _FORCE_INLINES +__STRING_INLINE void *__memrchr (const void *__s, int __c, size_t __n); + +__STRING_INLINE void * +__memrchr (const void *__s, int __c, size_t __n) +{ + register unsigned long int __d0; +# ifdef __i686__ + register unsigned long int __d1; +# endif + register void *__res; + if (__n == 0) + return NULL; +# ifdef __i686__ + __asm__ __volatile__ + ("std\n\t" + "repne; scasb\n\t" + "cmovne %2,%0\n\t" + "cld\n\t" + "incl %0" + : "=D" (__res), "=&c" (__d0), "=&r" (__d1) + : "a" (__c), "0" (__s + __n - 1), "1" (__n), "2" (-1), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "cc"); +# else + __asm__ __volatile__ + ("std\n\t" + "repne; scasb\n\t" + "je 1f\n\t" + "orl $-1,%0\n" + "1:\tcld\n\t" + "incl %0" + : "=D" (__res), "=&c" (__d0) + : "a" (__c), "0" (__s + __n - 1), "1" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "cc"); +# endif + return __res; +} +# ifdef __USE_GNU +# define memrchr(s, c, n) __memrchr ((s), (c), (n)) +# endif +# endif + +/* Return pointer to C in S. */ +# define _HAVE_STRING_ARCH_rawmemchr 1 +__STRING_INLINE void *__rawmemchr (const void *__s, int __c); + +# ifndef _FORCE_INLINES +__STRING_INLINE void * +__rawmemchr (const void *__s, int __c) +{ + register unsigned long int __d0; + register unsigned char *__res; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + : "=D" (__res), "=&c" (__d0) + : "a" (__c), "0" (__s), "1" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} +# ifdef __USE_GNU +__STRING_INLINE void * +rawmemchr (const void *__s, int __c) +{ + return __rawmemchr (__s, __c); +} +# endif /* use GNU */ +# endif + + +/* Return the length of S. */ +# define _HAVE_STRING_ARCH_strlen 1 +# define strlen(str) \ + (__extension__ (__builtin_constant_p (str) \ + ? __builtin_strlen (str) \ + : __strlen_g (str))) +__STRING_INLINE size_t __strlen_g (const char *__str); + +__STRING_INLINE size_t +__strlen_g (const char *__str) +{ + register char __dummy; + register const char *__tmp = __str; + __asm__ __volatile__ + ("1:\n\t" + "movb (%0),%b1\n\t" + "leal 1(%0),%0\n\t" + "testb %b1,%b1\n\t" + "jne 1b" + : "=r" (__tmp), "=&q" (__dummy) + : "0" (__str), + "m" ( *(struct { char __x[0xfffffff]; } *)__str) + : "cc" ); + return __tmp - __str - 1; +} + + +/* Copy SRC to DEST. */ +# define _HAVE_STRING_ARCH_strcpy 1 +# define strcpy(dest, src) \ + (__extension__ (__builtin_constant_p (src) \ + ? (sizeof ((src)[0]) == 1 && strlen (src) + 1 <= 8 \ + ? __strcpy_a_small ((dest), (src), strlen (src) + 1) \ + : (char *) memcpy ((char *) (dest), \ + (const char *) (src), \ + strlen (src) + 1)) \ + : __strcpy_g ((dest), (src)))) + +# define __strcpy_a_small(dest, src, srclen) \ + (__extension__ ({ char *__dest = (dest); \ + union { \ + unsigned int __ui; \ + unsigned short int __usi; \ + unsigned char __uc; \ + char __c; \ + } *__u = (void *) __dest; \ + switch (srclen) \ + { \ + case 1: \ + __u->__uc = '\0'; \ + break; \ + case 2: \ + __u->__usi = __STRING_SMALL_GET16 (src, 0); \ + break; \ + case 3: \ + __u->__usi = __STRING_SMALL_GET16 (src, 0); \ + __u = __extension__ ((void *) __u + 2); \ + __u->__uc = '\0'; \ + break; \ + case 4: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + break; \ + case 5: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__uc = '\0'; \ + break; \ + case 6: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__usi = __STRING_SMALL_GET16 (src, 4); \ + break; \ + case 7: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__usi = __STRING_SMALL_GET16 (src, 4); \ + __u = __extension__ ((void *) __u + 2); \ + __u->__uc = '\0'; \ + break; \ + case 8: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__ui = __STRING_SMALL_GET32 (src, 4); \ + break; \ + } \ + (char *) __dest; })) + +__STRING_INLINE char *__strcpy_g (char *__dest, const char *__src); + +__STRING_INLINE char * +__strcpy_g (char *__dest, const char *__src) +{ + register char *__tmp = __dest; + register char __dummy; + __asm__ __volatile__ + ( + "1:\n\t" + "movb (%0),%b2\n\t" + "leal 1(%0),%0\n\t" + "movb %b2,(%1)\n\t" + "leal 1(%1),%1\n\t" + "testb %b2,%b2\n\t" + "jne 1b" + : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy), + "=m" ( *(struct { char __x[0xfffffff]; } *)__dest) + : "0" (__src), "1" (__tmp), + "m" ( *(struct { char __x[0xfffffff]; } *)__src) + : "cc"); + return __dest; +} + + +# ifdef __USE_GNU +# define _HAVE_STRING_ARCH_stpcpy 1 +/* Copy SRC to DEST. */ +# define __stpcpy(dest, src) \ + (__extension__ (__builtin_constant_p (src) \ + ? (strlen (src) + 1 <= 8 \ + ? __stpcpy_a_small ((dest), (src), strlen (src) + 1) \ + : __stpcpy_c ((dest), (src), strlen (src) + 1)) \ + : __stpcpy_g ((dest), (src)))) +# define __stpcpy_c(dest, src, srclen) \ + ((srclen) % 4 == 0 \ + ? __mempcpy_by4 (dest, src, srclen) - 1 \ + : ((srclen) % 2 == 0 \ + ? __mempcpy_by2 (dest, src, srclen) - 1 \ + : __mempcpy_byn (dest, src, srclen) - 1)) + +/* In glibc itself we use this symbol for namespace reasons. */ +# define stpcpy(dest, src) __stpcpy ((dest), (src)) + +# define __stpcpy_a_small(dest, src, srclen) \ + (__extension__ ({ union { \ + unsigned int __ui; \ + unsigned short int __usi; \ + unsigned char __uc; \ + char __c; \ + } *__u = (void *) (dest); \ + switch (srclen) \ + { \ + case 1: \ + __u->__uc = '\0'; \ + break; \ + case 2: \ + __u->__usi = __STRING_SMALL_GET16 (src, 0); \ + __u = __extension__ ((void *) __u + 1); \ + break; \ + case 3: \ + __u->__usi = __STRING_SMALL_GET16 (src, 0); \ + __u = __extension__ ((void *) __u + 2); \ + __u->__uc = '\0'; \ + break; \ + case 4: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 3); \ + break; \ + case 5: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__uc = '\0'; \ + break; \ + case 6: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__usi = __STRING_SMALL_GET16 (src, 4); \ + __u = __extension__ ((void *) __u + 1); \ + break; \ + case 7: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__usi = __STRING_SMALL_GET16 (src, 4); \ + __u = __extension__ ((void *) __u + 2); \ + __u->__uc = '\0'; \ + break; \ + case 8: \ + __u->__ui = __STRING_SMALL_GET32 (src, 0); \ + __u = __extension__ ((void *) __u + 4); \ + __u->__ui = __STRING_SMALL_GET32 (src, 4); \ + __u = __extension__ ((void *) __u + 3); \ + break; \ + } \ + (char *) __u; })) + +__STRING_INLINE char *__mempcpy_by4 (char *__dest, const char *__src, + size_t __srclen); + +__STRING_INLINE char * +__mempcpy_by4 (char *__dest, const char *__src, size_t __srclen) +{ + register char *__tmp = __dest; + register unsigned long int __d0, __d1; + __asm__ __volatile__ + ("1:\n\t" + "movl (%2),%0\n\t" + "leal 4(%2),%2\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %3\n\t" + "jnz 1b" + : "=&r" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1) + : "1" (__tmp), "2" (__src), "3" (__srclen / 4) + : "memory", "cc"); + return __tmp; +} + +__STRING_INLINE char *__mempcpy_by2 (char *__dest, const char *__src, + size_t __srclen); + +__STRING_INLINE char * +__mempcpy_by2 (char *__dest, const char *__src, size_t __srclen) +{ + register char *__tmp = __dest; + register unsigned long int __d0, __d1; + __asm__ __volatile__ + ("shrl $1,%3\n\t" + "jz 2f\n" /* only a word */ + "1:\n\t" + "movl (%2),%0\n\t" + "leal 4(%2),%2\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %3\n\t" + "jnz 1b\n" + "2:\n\t" + "movw (%2),%w0\n\t" + "movw %w0,(%1)" + : "=&q" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1), + "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest) + : "1" (__tmp), "2" (__src), "3" (__srclen / 2), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); + return __tmp + 2; +} + +__STRING_INLINE char *__mempcpy_byn (char *__dest, const char *__src, + size_t __srclen); + +__STRING_INLINE char * +__mempcpy_byn (char *__dest, const char *__src, size_t __srclen) +{ + register unsigned long __d0, __d1; + register char *__tmp = __dest; + __asm__ __volatile__ + ("cld\n\t" + "shrl $1,%%ecx\n\t" + "jnc 1f\n\t" + "movsb\n" + "1:\n\t" + "shrl $1,%%ecx\n\t" + "jnc 2f\n\t" + "movsw\n" + "2:\n\t" + "rep; movsl" + : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1), + "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest) + : "0" (__tmp), "1" (__srclen), "2" (__src), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); + return __tmp; +} + +__STRING_INLINE char *__stpcpy_g (char *__dest, const char *__src); + +__STRING_INLINE char * +__stpcpy_g (char *__dest, const char *__src) +{ + register char *__tmp = __dest; + register char __dummy; + __asm__ __volatile__ + ( + "1:\n\t" + "movb (%0),%b2\n\t" + "leal 1(%0),%0\n\t" + "movb %b2,(%1)\n\t" + "leal 1(%1),%1\n\t" + "testb %b2,%b2\n\t" + "jne 1b" + : "=&r" (__src), "=r" (__tmp), "=&q" (__dummy), + "=m" ( *(struct { char __x[0xfffffff]; } *)__dest) + : "0" (__src), "1" (__tmp), + "m" ( *(struct { char __x[0xfffffff]; } *)__src) + : "cc"); + return __tmp - 1; +} +# endif + + +/* Copy no more than N characters of SRC to DEST. */ +# define _HAVE_STRING_ARCH_strncpy 1 +# define strncpy(dest, src, n) \ + (__extension__ (__builtin_constant_p (src) \ + ? ((strlen (src) + 1 >= ((size_t) (n)) \ + ? (char *) memcpy ((char *) (dest), \ + (const char *) (src), n) \ + : __strncpy_cg ((dest), (src), strlen (src) + 1, n))) \ + : __strncpy_gg ((dest), (src), n))) +# define __strncpy_cg(dest, src, srclen, n) \ + (((srclen) % 4 == 0) \ + ? __strncpy_by4 (dest, src, srclen, n) \ + : (((srclen) % 2 == 0) \ + ? __strncpy_by2 (dest, src, srclen, n) \ + : __strncpy_byn (dest, src, srclen, n))) + +__STRING_INLINE char *__strncpy_by4 (char *__dest, const char __src[], + size_t __srclen, size_t __n); + +__STRING_INLINE char * +__strncpy_by4 (char *__dest, const char __src[], size_t __srclen, size_t __n) +{ + register char *__tmp = __dest; + register int __dummy1, __dummy2; + __asm__ __volatile__ + ("1:\n\t" + "movl (%2),%0\n\t" + "leal 4(%2),%2\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %3\n\t" + "jnz 1b" + : "=&r" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2), + "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest) + : "1" (__tmp), "2" (__src), "3" (__srclen / 4), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); + (void) memset (__tmp, '\0', __n - __srclen); + return __dest; +} + +__STRING_INLINE char *__strncpy_by2 (char *__dest, const char __src[], + size_t __srclen, size_t __n); + +__STRING_INLINE char * +__strncpy_by2 (char *__dest, const char __src[], size_t __srclen, size_t __n) +{ + register char *__tmp = __dest; + register int __dummy1, __dummy2; + __asm__ __volatile__ + ("shrl $1,%3\n\t" + "jz 2f\n" /* only a word */ + "1:\n\t" + "movl (%2),%0\n\t" + "leal 4(%2),%2\n\t" + "movl %0,(%1)\n\t" + "leal 4(%1),%1\n\t" + "decl %3\n\t" + "jnz 1b\n" + "2:\n\t" + "movw (%2),%w0\n\t" + "movw %w0,(%1)\n\t" + : "=&q" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2), + "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest) + : "1" (__tmp), "2" (__src), "3" (__srclen / 2), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); + (void) memset (__tmp + 2, '\0', __n - __srclen); + return __dest; +} + +__STRING_INLINE char *__strncpy_byn (char *__dest, const char __src[], + size_t __srclen, size_t __n); + +__STRING_INLINE char * +__strncpy_byn (char *__dest, const char __src[], size_t __srclen, size_t __n) +{ + register unsigned long int __d0, __d1; + register char *__tmp = __dest; + __asm__ __volatile__ + ("cld\n\t" + "shrl $1,%1\n\t" + "jnc 1f\n\t" + "movsb\n" + "1:\n\t" + "shrl $1,%1\n\t" + "jnc 2f\n\t" + "movsw\n" + "2:\n\t" + "rep; movsl" + : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1), + "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest) + : "1" (__srclen), "0" (__tmp),"2" (__src), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); + (void) memset (__tmp, '\0', __n - __srclen); + return __dest; +} + +__STRING_INLINE char *__strncpy_gg (char *__dest, const char *__src, + size_t __n); + +__STRING_INLINE char * +__strncpy_gg (char *__dest, const char *__src, size_t __n) +{ + register char *__tmp = __dest; + register char __dummy; + if (__n > 0) + __asm__ __volatile__ + ("1:\n\t" + "movb (%0),%2\n\t" + "incl %0\n\t" + "movb %2,(%1)\n\t" + "incl %1\n\t" + "decl %3\n\t" + "je 3f\n\t" + "testb %2,%2\n\t" + "jne 1b\n\t" + "2:\n\t" + "movb %2,(%1)\n\t" + "incl %1\n\t" + "decl %3\n\t" + "jne 2b\n\t" + "3:" + : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy), "=&r" (__n) + : "0" (__src), "1" (__tmp), "3" (__n) + : "memory", "cc"); + + return __dest; +} + + +/* Append SRC onto DEST. */ +# define _HAVE_STRING_ARCH_strcat 1 +# define strcat(dest, src) \ + (__extension__ (__builtin_constant_p (src) \ + ? __strcat_c ((dest), (src), strlen (src) + 1) \ + : __strcat_g ((dest), (src)))) + +__STRING_INLINE char *__strcat_c (char *__dest, const char __src[], + size_t __srclen); + +__STRING_INLINE char * +__strcat_c (char *__dest, const char __src[], size_t __srclen) +{ +# ifdef __i686__ + register unsigned long int __d0; + register char *__tmp; + __asm__ __volatile__ + ("repne; scasb" + : "=D" (__tmp), "=&c" (__d0), + "=m" ( *(struct { char __x[0xfffffff]; } *)__dest) + : "0" (__dest), "1" (0xffffffff), "a" (0), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); + --__tmp; +# else + register char *__tmp = __dest - 1; + __asm__ __volatile__ + ("1:\n\t" + "incl %0\n\t" + "cmpb $0,(%0)\n\t" + "jne 1b\n" + : "=r" (__tmp), + "=m" ( *(struct { char __x[0xfffffff]; } *)__dest) + : "0" (__tmp), + "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src) + : "cc"); +# endif + (void) memcpy (__tmp, __src, __srclen); + return __dest; +} + +__STRING_INLINE char *__strcat_g (char *__dest, const char *__src); + +__STRING_INLINE char * +__strcat_g (char *__dest, const char *__src) +{ + register char *__tmp = __dest - 1; + register char __dummy; + __asm__ __volatile__ + ("1:\n\t" + "incl %1\n\t" + "cmpb $0,(%1)\n\t" + "jne 1b\n" + "2:\n\t" + "movb (%2),%b0\n\t" + "incl %2\n\t" + "movb %b0,(%1)\n\t" + "incl %1\n\t" + "testb %b0,%b0\n\t" + "jne 2b\n" + : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src), + "=m" ( *(struct { char __x[0xfffffff]; } *)__dest) + : "1" (__tmp), "2" (__src), + "m" ( *(struct { char __x[0xfffffff]; } *)__src) + : "memory", "cc"); + return __dest; +} + + +/* Append no more than N characters from SRC onto DEST. */ +# define _HAVE_STRING_ARCH_strncat 1 +# define strncat(dest, src, n) \ + (__extension__ ({ char *__dest = (dest); \ + __builtin_constant_p (src) && __builtin_constant_p (n) \ + ? (strlen (src) < ((size_t) (n)) \ + ? strcat (__dest, (src)) \ + : (*(char *)__mempcpy (strchr (__dest, '\0'), \ + (const char *) (src), \ + (n)) = 0, __dest)) \ + : __strncat_g (__dest, (src), (n)); })) + +__STRING_INLINE char *__strncat_g (char *__dest, const char __src[], + size_t __n); + +__STRING_INLINE char * +__strncat_g (char *__dest, const char __src[], size_t __n) +{ + register char *__tmp = __dest; + register char __dummy; +# ifdef __i686__ + __asm__ __volatile__ + ("repne; scasb\n" + "movl %4, %3\n\t" + "decl %1\n\t" + "1:\n\t" + "subl $1,%3\n\t" + "jc 2f\n\t" + "movb (%2),%b0\n\t" + "movsb\n\t" + "testb %b0,%b0\n\t" + "jne 1b\n\t" + "decl %1\n" + "2:\n\t" + "movb $0,(%1)" + : "=&a" (__dummy), "=&D" (__tmp), "=&S" (__src), "=&c" (__n) + : "g" (__n), "0" (0), "1" (__tmp), "2" (__src), "3" (0xffffffff) + : "memory", "cc"); +# else + --__tmp; + __asm__ __volatile__ + ("1:\n\t" + "cmpb $0,1(%1)\n\t" + "leal 1(%1),%1\n\t" + "jne 1b\n" + "2:\n\t" + "subl $1,%3\n\t" + "jc 3f\n\t" + "movb (%2),%b0\n\t" + "leal 1(%2),%2\n\t" + "movb %b0,(%1)\n\t" + "leal 1(%1),%1\n\t" + "testb %b0,%b0\n\t" + "jne 2b\n\t" + "decl %1\n" + "3:\n\t" + "movb $0,(%1)" + : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src), "=&r" (__n) + : "1" (__tmp), "2" (__src), "3" (__n) + : "memory", "cc"); +#endif + return __dest; +} + + +/* Compare S1 and S2. */ +# define _HAVE_STRING_ARCH_strcmp 1 +# define strcmp(s1, s2) \ + (__extension__ (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ + && (sizeof ((s1)[0]) != 1 || strlen (s1) >= 4) \ + && (sizeof ((s2)[0]) != 1 || strlen (s2) >= 4) \ + ? memcmp ((const char *) (s1), (const char *) (s2), \ + (strlen (s1) < strlen (s2) \ + ? strlen (s1) : strlen (s2)) + 1) \ + : (__builtin_constant_p (s1) && sizeof ((s1)[0]) == 1 \ + && sizeof ((s2)[0]) == 1 && strlen (s1) < 4 \ + ? (__builtin_constant_p (s2) && sizeof ((s2)[0]) == 1 \ + ? __strcmp_cc ((const unsigned char *) (s1), \ + (const unsigned char *) (s2), \ + strlen (s1)) \ + : __strcmp_cg ((const unsigned char *) (s1), \ + (const unsigned char *) (s2), \ + strlen (s1))) \ + : (__builtin_constant_p (s2) && sizeof ((s1)[0]) == 1 \ + && sizeof ((s2)[0]) == 1 && strlen (s2) < 4 \ + ? (__builtin_constant_p (s1) \ + ? __strcmp_cc ((const unsigned char *) (s1), \ + (const unsigned char *) (s2), \ + strlen (s2)) \ + : __strcmp_gc ((const unsigned char *) (s1), \ + (const unsigned char *) (s2), \ + strlen (s2))) \ + : __strcmp_gg ((s1), (s2)))))) + +# define __strcmp_cc(s1, s2, l) \ + (__extension__ ({ register int __result = (s1)[0] - (s2)[0]; \ + if (l > 0 && __result == 0) \ + { \ + __result = (s1)[1] - (s2)[1]; \ + if (l > 1 && __result == 0) \ + { \ + __result = (s1)[2] - (s2)[2]; \ + if (l > 2 && __result == 0) \ + __result = (s1)[3] - (s2)[3]; \ + } \ + } \ + __result; })) + +# define __strcmp_cg(s1, s2, l1) \ + (__extension__ ({ const unsigned char *__s2 = (s2); \ + register int __result = (s1)[0] - __s2[0]; \ + if (l1 > 0 && __result == 0) \ + { \ + __result = (s1)[1] - __s2[1]; \ + if (l1 > 1 && __result == 0) \ + { \ + __result = (s1)[2] - __s2[2]; \ + if (l1 > 2 && __result == 0) \ + __result = (s1)[3] - __s2[3]; \ + } \ + } \ + __result; })) + +# define __strcmp_gc(s1, s2, l2) \ + (__extension__ ({ const unsigned char *__s1 = (s1); \ + register int __result = __s1[0] - (s2)[0]; \ + if (l2 > 0 && __result == 0) \ + { \ + __result = __s1[1] - (s2)[1]; \ + if (l2 > 1 && __result == 0) \ + { \ + __result = __s1[2] - (s2)[2]; \ + if (l2 > 2 && __result == 0) \ + __result = __s1[3] - (s2)[3]; \ + } \ + } \ + __result; })) + +__STRING_INLINE int __strcmp_gg (const char *__s1, const char *__s2); + +__STRING_INLINE int +__strcmp_gg (const char *__s1, const char *__s2) +{ + register int __res; + __asm__ __volatile__ + ("1:\n\t" + "movb (%1),%b0\n\t" + "leal 1(%1),%1\n\t" + "cmpb %b0,(%2)\n\t" + "jne 2f\n\t" + "leal 1(%2),%2\n\t" + "testb %b0,%b0\n\t" + "jne 1b\n\t" + "xorl %0,%0\n\t" + "jmp 3f\n" + "2:\n\t" + "movl $1,%0\n\t" + "jb 3f\n\t" + "negl %0\n" + "3:" + : "=q" (__res), "=&r" (__s1), "=&r" (__s2) + : "1" (__s1), "2" (__s2), + "m" ( *(struct { char __x[0xfffffff]; } *)__s1), + "m" ( *(struct { char __x[0xfffffff]; } *)__s2) + : "cc"); + return __res; +} + + +/* Compare N characters of S1 and S2. */ +# define _HAVE_STRING_ARCH_strncmp 1 +# define strncmp(s1, s2, n) \ + (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n)) \ + ? strcmp ((s1), (s2)) \ + : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\ + ? strcmp ((s1), (s2)) \ + : __strncmp_g ((s1), (s2), (n))))) + +__STRING_INLINE int __strncmp_g (const char *__s1, const char *__s2, + size_t __n); + +__STRING_INLINE int +__strncmp_g (const char *__s1, const char *__s2, size_t __n) +{ + register int __res; + __asm__ __volatile__ + ("1:\n\t" + "subl $1,%3\n\t" + "jc 2f\n\t" + "movb (%1),%b0\n\t" + "incl %1\n\t" + "cmpb %b0,(%2)\n\t" + "jne 3f\n\t" + "incl %2\n\t" + "testb %b0,%b0\n\t" + "jne 1b\n" + "2:\n\t" + "xorl %0,%0\n\t" + "jmp 4f\n" + "3:\n\t" + "movl $1,%0\n\t" + "jb 4f\n\t" + "negl %0\n" + "4:" + : "=q" (__res), "=&r" (__s1), "=&r" (__s2), "=&r" (__n) + : "1" (__s1), "2" (__s2), "3" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s1), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s2) + : "cc"); + return __res; +} + + +/* Find the first occurrence of C in S. */ +# define _HAVE_STRING_ARCH_strchr 1 +# define _USE_STRING_ARCH_strchr 1 +# define strchr(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? ((c) == '\0' \ + ? (char *) __rawmemchr ((s), (c)) \ + : __strchr_c ((s), ((c) & 0xff) << 8)) \ + : __strchr_g ((s), (c)))) + +__STRING_INLINE char *__strchr_c (const char *__s, int __c); + +__STRING_INLINE char * +__strchr_c (const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("1:\n\t" + "movb (%0),%%al\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "leal 1(%0),%0\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "xorl %0,%0\n" + "2:" + : "=r" (__res), "=&a" (__d0) + : "0" (__s), "1" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} + +__STRING_INLINE char *__strchr_g (const char *__s, int __c); + +__STRING_INLINE char * +__strchr_g (const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("movb %%al,%%ah\n" + "1:\n\t" + "movb (%0),%%al\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "leal 1(%0),%0\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "xorl %0,%0\n" + "2:" + : "=r" (__res), "=&a" (__d0) + : "0" (__s), "1" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} + + +/* Find the first occurrence of C in S or the final NUL byte. */ +# define _HAVE_STRING_ARCH_strchrnul 1 +# define __strchrnul(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? ((c) == '\0' \ + ? (char *) __rawmemchr ((s), c) \ + : __strchrnul_c ((s), ((c) & 0xff) << 8)) \ + : __strchrnul_g ((s), c))) + +__STRING_INLINE char *__strchrnul_c (const char *__s, int __c); + +__STRING_INLINE char * +__strchrnul_c (const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("1:\n\t" + "movb (%0),%%al\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "leal 1(%0),%0\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "decl %0\n" + "2:" + : "=r" (__res), "=&a" (__d0) + : "0" (__s), "1" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} + +__STRING_INLINE char *__strchrnul_g (const char *__s, int __c); + +__STRING_INLINE char * +__strchrnul_g (const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("movb %%al,%%ah\n" + "1:\n\t" + "movb (%0),%%al\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "leal 1(%0),%0\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "decl %0\n" + "2:" + : "=r" (__res), "=&a" (__d0) + : "0" (__s), "1" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} +# ifdef __USE_GNU +# define strchrnul(s, c) __strchrnul ((s), (c)) +# endif + + +# if defined __USE_MISC || defined __USE_XOPEN_EXTENDED +/* Find the first occurrence of C in S. This is the BSD name. */ +# define _HAVE_STRING_ARCH_index 1 +# define index(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? __strchr_c ((s), ((c) & 0xff) << 8) \ + : __strchr_g ((s), (c)))) +# endif + + +/* Find the last occurrence of C in S. */ +# define _HAVE_STRING_ARCH_strrchr 1 +# define strrchr(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? __strrchr_c ((s), ((c) & 0xff) << 8) \ + : __strrchr_g ((s), (c)))) + +# ifdef __i686__ +__STRING_INLINE char *__strrchr_c (const char *__s, int __c); + +__STRING_INLINE char * +__strrchr_c (const char *__s, int __c) +{ + register unsigned long int __d0, __d1; + register char *__res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "cmpb %h2,%b2\n\t" + "cmove %1,%0\n\t" + "testb %b2,%b2\n\t" + "jne 1b" + : "=d" (__res), "=&S" (__d0), "=&a" (__d1) + : "0" (1), "1" (__s), "2" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} + +__STRING_INLINE char *__strrchr_g (const char *__s, int __c); + +__STRING_INLINE char * +__strrchr_g (const char *__s, int __c) +{ + register unsigned long int __d0, __d1; + register char *__res; + __asm__ __volatile__ + ("movb %b2,%h2\n" + "cld\n\t" + "1:\n\t" + "lodsb\n\t" + "cmpb %h2,%b2\n\t" + "cmove %1,%0\n\t" + "testb %b2,%b2\n\t" + "jne 1b" + : "=d" (__res), "=&S" (__d0), "=&a" (__d1) + : "0" (1), "1" (__s), "2" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} +# else +__STRING_INLINE char *__strrchr_c (const char *__s, int __c); + +__STRING_INLINE char * +__strrchr_c (const char *__s, int __c) +{ + register unsigned long int __d0, __d1; + register char *__res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "cmpb %%ah,%%al\n\t" + "jne 2f\n\t" + "leal -1(%%esi),%0\n" + "2:\n\t" + "testb %%al,%%al\n\t" + "jne 1b" + : "=d" (__res), "=&S" (__d0), "=&a" (__d1) + : "0" (0), "1" (__s), "2" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} + +__STRING_INLINE char *__strrchr_g (const char *__s, int __c); + +__STRING_INLINE char * +__strrchr_g (const char *__s, int __c) +{ + register unsigned long int __d0, __d1; + register char *__res; + __asm__ __volatile__ + ("movb %%al,%%ah\n" + "cld\n\t" + "1:\n\t" + "lodsb\n\t" + "cmpb %%ah,%%al\n\t" + "jne 2f\n\t" + "leal -1(%%esi),%0\n" + "2:\n\t" + "testb %%al,%%al\n\t" + "jne 1b" + : "=r" (__res), "=&S" (__d0), "=&a" (__d1) + : "0" (0), "1" (__s), "2" (__c), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} +# endif + + +# if defined __USE_MISC || defined __USE_XOPEN_EXTENDED +/* Find the last occurrence of C in S. This is the BSD name. */ +# define _HAVE_STRING_ARCH_rindex 1 +# define rindex(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? __strrchr_c ((s), ((c) & 0xff) << 8) \ + : __strrchr_g ((s), (c)))) +# endif + + +/* Return the length of the initial segment of S which + consists entirely of characters not in REJECT. */ +# define _HAVE_STRING_ARCH_strcspn 1 +# define strcspn(s, reject) \ + (__extension__ (__builtin_constant_p (reject) && sizeof ((reject)[0]) == 1 \ + ? ((reject)[0] == '\0' \ + ? strlen (s) \ + : ((reject)[1] == '\0' \ + ? __strcspn_c1 ((s), (((reject)[0] << 8) & 0xff00)) \ + : __strcspn_cg ((s), (reject), strlen (reject)))) \ + : __strcspn_g ((s), (reject)))) + +__STRING_INLINE size_t __strcspn_c1 (const char *__s, int __reject); + +# ifndef _FORCE_INLINES +__STRING_INLINE size_t +__strcspn_c1 (const char *__s, int __reject) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("1:\n\t" + "movb (%0),%%al\n\t" + "leal 1(%0),%0\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n" + "2:" + : "=r" (__res), "=&a" (__d0) + : "0" (__s), "1" (__reject), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return (__res - 1) - __s; +} +# endif + +__STRING_INLINE size_t __strcspn_cg (const char *__s, const char __reject[], + size_t __reject_len); + +__STRING_INLINE size_t +__strcspn_cg (const char *__s, const char __reject[], size_t __reject_len) +{ + register unsigned long int __d0, __d1, __d2; + register const char *__res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %5,%%edi\n\t" + "movl %6,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n" + "2:" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "0" (__s), "d" (__reject), "g" (__reject_len) + : "memory", "cc"); + return (__res - 1) - __s; +} + +__STRING_INLINE size_t __strcspn_g (const char *__s, const char *__reject); +# ifdef __PIC__ + +__STRING_INLINE size_t +__strcspn_g (const char *__s, const char *__reject) +{ + register unsigned long int __d0, __d1, __d2; + register const char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "movl %4,%%edi\n\t" + "cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "leal -1(%%ecx),%%ebx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %4,%%edi\n\t" + "movl %%ebx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n" + "2:\n\t" + "popl %%ebx" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "r" (__reject), "0" (__s), "1" (0), "2" (0xffffffff) + : "memory", "cc"); + return (__res - 1) - __s; +} +# else +__STRING_INLINE size_t +__strcspn_g (const char *__s, const char *__reject) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register const char *__res; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "leal -1(%%ecx),%%edx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %%ebx,%%edi\n\t" + "movl %%edx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n" + "2:" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3) + : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__reject), "b" (__reject) + /* Clobber memory, otherwise GCC cannot handle this. */ + : "memory", "cc"); + return (__res - 1) - __s; +} +# endif + + +/* Return the length of the initial segment of S which + consists entirely of characters in ACCEPT. */ +# define _HAVE_STRING_ARCH_strspn 1 +# define strspn(s, accept) \ + (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1 \ + ? ((accept)[0] == '\0' \ + ? ((void) (s), 0) \ + : ((accept)[1] == '\0' \ + ? __strspn_c1 ((s), (((accept)[0] << 8 ) & 0xff00)) \ + : __strspn_cg ((s), (accept), strlen (accept)))) \ + : __strspn_g ((s), (accept)))) + +# ifndef _FORCE_INLINES +__STRING_INLINE size_t __strspn_c1 (const char *__s, int __accept); + +__STRING_INLINE size_t +__strspn_c1 (const char *__s, int __accept) +{ + register unsigned long int __d0; + register char *__res; + /* Please note that __accept never can be '\0'. */ + __asm__ __volatile__ + ("1:\n\t" + "movb (%0),%b1\n\t" + "leal 1(%0),%0\n\t" + "cmpb %h1,%b1\n\t" + "je 1b" + : "=r" (__res), "=&q" (__d0) + : "0" (__s), "1" (__accept), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return (__res - 1) - __s; +} +# endif + +__STRING_INLINE size_t __strspn_cg (const char *__s, const char __accept[], + size_t __accept_len); + +__STRING_INLINE size_t +__strspn_cg (const char *__s, const char __accept[], size_t __accept_len) +{ + register unsigned long int __d0, __d1, __d2; + register const char *__res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %5,%%edi\n\t" + "movl %6,%%ecx\n\t" + "repne; scasb\n\t" + "je 1b\n" + "2:" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "0" (__s), "g" (__accept), "g" (__accept_len), + /* Since we do not know how large the memory we access it, use a + really large amount. */ + "m" ( *(struct { char __x[0xfffffff]; } *)__s), + "m" ( *(struct { __extension__ char __x[__accept_len]; } *)__accept) + : "cc"); + return (__res - 1) - __s; +} + +__STRING_INLINE size_t __strspn_g (const char *__s, const char *__accept); +# ifdef __PIC__ + +__STRING_INLINE size_t +__strspn_g (const char *__s, const char *__accept) +{ + register unsigned long int __d0, __d1, __d2; + register const char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "leal -1(%%ecx),%%ebx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %%edx,%%edi\n\t" + "movl %%ebx,%%ecx\n\t" + "repne; scasb\n\t" + "je 1b\n" + "2:\n\t" + "popl %%ebx" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept) + : "memory", "cc"); + return (__res - 1) - __s; +} +# else +__STRING_INLINE size_t +__strspn_g (const char *__s, const char *__accept) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register const char *__res; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "leal -1(%%ecx),%%edx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %%ebx,%%edi\n\t" + "movl %%edx,%%ecx\n\t" + "repne; scasb\n\t" + "je 1b\n" + "2:" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3) + : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept), "b" (__accept) + : "memory", "cc"); + return (__res - 1) - __s; +} +# endif + + +/* Find the first occurrence in S of any character in ACCEPT. */ +# define _HAVE_STRING_ARCH_strpbrk 1 +# define strpbrk(s, accept) \ + (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1 \ + ? ((accept)[0] == '\0' \ + ? ((void) (s), (char *) 0) \ + : ((accept)[1] == '\0' \ + ? strchr ((s), (accept)[0]) \ + : __strpbrk_cg ((s), (accept), strlen (accept)))) \ + : __strpbrk_g ((s), (accept)))) + +__STRING_INLINE char *__strpbrk_cg (const char *__s, const char __accept[], + size_t __accept_len); + +__STRING_INLINE char * +__strpbrk_cg (const char *__s, const char __accept[], size_t __accept_len) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %5,%%edi\n\t" + "movl %6,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n\t" + "decl %0\n\t" + "jmp 3f\n" + "2:\n\t" + "xorl %0,%0\n" + "3:" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "0" (__s), "d" (__accept), "g" (__accept_len) + : "memory", "cc"); + return __res; +} + +__STRING_INLINE char *__strpbrk_g (const char *__s, const char *__accept); +# ifdef __PIC__ + +__STRING_INLINE char * +__strpbrk_g (const char *__s, const char *__accept) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "movl %%edx,%%edi\n\t" + "cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "leal -1(%%ecx),%%ebx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %%edx,%%edi\n\t" + "movl %%ebx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n\t" + "decl %0\n\t" + "jmp 3f\n" + "2:\n\t" + "xorl %0,%0\n" + "3:\n\t" + "popl %%ebx" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff) + : "memory", "cc"); + return __res; +} +# else +__STRING_INLINE char * +__strpbrk_g (const char *__s, const char *__accept) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register char *__res; + __asm__ __volatile__ + ("movl %%ebx,%%edi\n\t" + "cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "leal -1(%%ecx),%%edx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %%ebx,%%edi\n\t" + "movl %%edx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n\t" + "decl %0\n\t" + "jmp 3f\n" + "2:\n\t" + "xorl %0,%0\n" + "3:" + : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3) + : "0" (__s), "1" (0), "2" (0xffffffff), "b" (__accept) + : "memory", "cc"); + return __res; +} +# endif + + +/* Find the first occurrence of NEEDLE in HAYSTACK. */ +# define _HAVE_STRING_ARCH_strstr 1 +# define strstr(haystack, needle) \ + (__extension__ (__builtin_constant_p (needle) && sizeof ((needle)[0]) == 1 \ + ? ((needle)[0] == '\0' \ + ? (haystack) \ + : ((needle)[1] == '\0' \ + ? strchr ((haystack), (needle)[0]) \ + : __strstr_cg ((haystack), (needle), \ + strlen (needle)))) \ + : __strstr_g ((haystack), (needle)))) + +/* Please note that this function need not handle NEEDLEs with a + length shorter than two. */ +__STRING_INLINE char *__strstr_cg (const char *__haystack, + const char __needle[], + size_t __needle_len); + +__STRING_INLINE char * +__strstr_cg (const char *__haystack, const char __needle[], + size_t __needle_len) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("cld\n" \ + "1:\n\t" + "movl %6,%%edi\n\t" + "movl %5,%%eax\n\t" + "movl %4,%%ecx\n\t" + "repe; cmpsb\n\t" + "je 2f\n\t" + "cmpb $0,-1(%%esi)\n\t" + "leal 1(%%eax),%5\n\t" + "jne 1b\n\t" + "xorl %%eax,%%eax\n" + "2:" + : "=&a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2) + : "g" (__needle_len), "1" (__haystack), "d" (__needle) + : "memory", "cc"); + return __res; +} + +__STRING_INLINE char *__strstr_g (const char *__haystack, + const char *__needle); +# ifdef __PIC__ + +__STRING_INLINE char * +__strstr_g (const char *__haystack, const char *__needle) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "pushl %%ebx\n\t" + "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */ + "movl %%ecx,%%ebx\n" + "1:\n\t" + "movl %%edx,%%edi\n\t" + "movl %%esi,%%eax\n\t" + "movl %%ebx,%%ecx\n\t" + "repe; cmpsb\n\t" + "je 2f\n\t" /* also works for empty string, see above */ + "cmpb $0,-1(%%esi)\n\t" + "leal 1(%%eax),%%esi\n\t" + "jne 1b\n\t" + "xorl %%eax,%%eax\n" + "2:\n\t" + "popl %%ebx" + : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2) + : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle), + "d" (__needle) + : "memory", "cc"); + return __res; +} +# else +__STRING_INLINE char * +__strstr_g (const char *__haystack, const char *__needle) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */ + "movl %%ecx,%%edx\n" + "1:\n\t" + "movl %%ebx,%%edi\n\t" + "movl %%esi,%%eax\n\t" + "movl %%edx,%%ecx\n\t" + "repe; cmpsb\n\t" + "je 2f\n\t" /* also works for empty string, see above */ + "cmpb $0,-1(%%esi)\n\t" + "leal 1(%%eax),%%esi\n\t" + "jne 1b\n\t" + "xorl %%eax,%%eax\n" + "2:" + : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), "=&d" (__d3) + : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle), + "b" (__needle) + : "memory", "cc"); + return __res; +} +# endif + + +/* Bit find functions. We define only the i686 version since for the other + processors gcc generates good code. */ +# if defined __USE_MISC || defined __USE_XOPEN_EXTENDED +# ifdef __i686__ +# define _HAVE_STRING_ARCH_ffs 1 +# define ffs(word) (__builtin_constant_p (word) \ + ? __builtin_ffs (word) \ + : ({ int __cnt, __tmp; \ + __asm__ __volatile__ \ + ("bsfl %2,%0\n\t" \ + "cmovel %1,%0" \ + : "=&r" (__cnt), "=r" (__tmp) \ + : "rm" (word), "1" (-1)); \ + __cnt + 1; })) + +# ifndef ffsl +# define ffsl(word) ffs(word) +# endif +# endif /* i686 */ +# endif /* Misc || X/Open */ + +# ifndef _FORCE_INLINES +# undef __STRING_INLINE +# endif + +# endif /* use string inlines && GNU CC */ + +#endif diff --git a/libktorrent/miniboost/bits/string2.h b/libktorrent/miniboost/bits/string2.h new file mode 100644 index 00000000..0523a273 --- /dev/null +++ b/libktorrent/miniboost/bits/string2.h @@ -0,0 +1,1329 @@ +/* Machine-independant string function optimizations. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 1997. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STRING_H +# error "Never use directly; include instead." +#endif + +#ifndef __NO_STRING_INLINES + +/* Unlike the definitions in the header the + definitions contained here are not optimized down to assembler + level. Those optimizations are not always a good idea since this + means the code size increases a lot. Instead the definitions here + optimize some functions in a way which do not dramatically + increase the code size and which do not use assembler. The main + trick is to use GCC's `__builtin_constant_p' function. + + Every function XXX which has a defined version in + must be accompanied by a symbol _HAVE_STRING_ARCH_XXX + to make sure we don't get redefinitions. + + We must use here macros instead of inline functions since the + trick won't work with the latter. */ + +#ifndef __STRING_INLINE +# ifdef __cplusplus +# define __STRING_INLINE inline +# else +# define __STRING_INLINE __extern_inline +# endif +#endif + +#if _STRING_ARCH_unaligned +/* If we can do unaligned memory accesses we must know the endianess. */ +# include +# include + +# if __BYTE_ORDER == __LITTLE_ENDIAN +# define __STRING2_SMALL_GET16(src, idx) \ + (((const unsigned char *) (const char *) (src))[idx + 1] << 8 \ + | ((const unsigned char *) (const char *) (src))[idx]) +# define __STRING2_SMALL_GET32(src, idx) \ + (((((const unsigned char *) (const char *) (src))[idx + 3] << 8 \ + | ((const unsigned char *) (const char *) (src))[idx + 2]) << 8 \ + | ((const unsigned char *) (const char *) (src))[idx + 1]) << 8 \ + | ((const unsigned char *) (const char *) (src))[idx]) +# else +# define __STRING2_SMALL_GET16(src, idx) \ + (((const unsigned char *) (const char *) (src))[idx] << 8 \ + | ((const unsigned char *) (const char *) (src))[idx + 1]) +# define __STRING2_SMALL_GET32(src, idx) \ + (((((const unsigned char *) (const char *) (src))[idx] << 8 \ + | ((const unsigned char *) (const char *) (src))[idx + 1]) << 8 \ + | ((const unsigned char *) (const char *) (src))[idx + 2]) << 8 \ + | ((const unsigned char *) (const char *) (src))[idx + 3]) +# endif +#else +/* These are a few types we need for the optimizations if we cannot + use unaligned memory accesses. */ +# define __STRING2_COPY_TYPE(N) \ + typedef struct { unsigned char __arr[N]; } \ + __attribute__ ((__packed__)) __STRING2_COPY_ARR##N +__STRING2_COPY_TYPE (2); +__STRING2_COPY_TYPE (3); +__STRING2_COPY_TYPE (4); +__STRING2_COPY_TYPE (5); +__STRING2_COPY_TYPE (6); +__STRING2_COPY_TYPE (7); +__STRING2_COPY_TYPE (8); +# undef __STRING2_COPY_TYPE +#endif + +/* Dereferencing a pointer arg to run sizeof on it fails for the void + pointer case, so we use this instead. + Note that __x is evaluated twice. */ +#define __string2_1bptr_p(__x) \ + ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1) + +/* Set N bytes of S to C. */ +#if !defined _HAVE_STRING_ARCH_memset +# if !__GNUC_PREREQ (3, 0) +# if _STRING_ARCH_unaligned +# define memset(s, c, n) \ + (__extension__ (__builtin_constant_p (n) && (n) <= 16 \ + ? ((n) == 1 \ + ? __memset_1 (s, c) \ + : __memset_gc (s, c, n)) \ + : (__builtin_constant_p (c) && (c) == '\0' \ + ? ({ void *__s = (s); __bzero (__s, n); __s; }) \ + : memset (s, c, n)))) + +# define __memset_1(s, c) ({ void *__s = (s); \ + *((__uint8_t *) __s) = (__uint8_t) c; __s; }) + +# define __memset_gc(s, c, n) \ + ({ void *__s = (s); \ + union { \ + unsigned int __ui; \ + unsigned short int __usi; \ + unsigned char __uc; \ + } *__u = __s; \ + __uint8_t __c = (__uint8_t) (c); \ + \ + /* This `switch' statement will be removed at compile-time. */ \ + switch ((unsigned int) (n)) \ + { \ + case 15: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 11: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 7: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 3: \ + __u->__usi = (unsigned short int) __c * 0x0101; \ + __u = __extension__ ((void *) __u + 2); \ + __u->__uc = (unsigned char) __c; \ + break; \ + \ + case 14: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 10: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 6: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 2: \ + __u->__usi = (unsigned short int) __c * 0x0101; \ + break; \ + \ + case 13: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 9: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 5: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 1: \ + __u->__uc = (unsigned char) __c; \ + break; \ + \ + case 16: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 12: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 8: \ + __u->__ui = __c * 0x01010101; \ + __u = __extension__ ((void *) __u + 4); \ + case 4: \ + __u->__ui = __c * 0x01010101; \ + case 0: \ + break; \ + } \ + \ + __s; }) +# else +# define memset(s, c, n) \ + (__extension__ (__builtin_constant_p (c) && (c) == '\0' \ + ? ({ void *__s = (s); __bzero (__s, n); __s; }) \ + : memset (s, c, n))) +# endif +# endif + +/* GCC < 3.0 optimizes memset(s, 0, n) but not bzero(s, n). + The optimization is broken before EGCS 1.1. + GCC 3.0+ has __builtin_bzero as well, but at least till GCC 3.4 + if it decides to call the library function, it calls memset + and not bzero. */ +# if __GNUC_PREREQ (2, 91) +# define __bzero(s, n) __builtin_memset (s, '\0', n) +# endif + +#endif + + +/* Copy N bytes from SRC to DEST, returning pointer to byte following the + last copied. */ +#ifdef __USE_GNU +# if !defined _HAVE_STRING_ARCH_mempcpy || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_mempcpy +# if __GNUC_PREREQ (3, 4) +# define __mempcpy(dest, src, n) __builtin_mempcpy (dest, src, n) +# elif __GNUC_PREREQ (3, 0) +# define __mempcpy(dest, src, n) \ + (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ + && __string2_1bptr_p (src) && n <= 8 \ + ? __builtin_memcpy (dest, src, n) + (n) \ + : __mempcpy (dest, src, n))) +# else +# define __mempcpy(dest, src, n) \ + (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ + && __string2_1bptr_p (src) && n <= 8 \ + ? __mempcpy_small (dest, __mempcpy_args (src), n) \ + : __mempcpy (dest, src, n))) +# endif +/* In glibc we use this function frequently but for namespace reasons + we have to use the name `__mempcpy'. */ +# define mempcpy(dest, src, n) __mempcpy (dest, src, n) +# endif + +# if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES +# if _STRING_ARCH_unaligned +# ifndef _FORCE_INLINES +# define __mempcpy_args(src) \ + ((const char *) (src))[0], ((const char *) (src))[2], \ + ((const char *) (src))[4], ((const char *) (src))[6], \ + __extension__ __STRING2_SMALL_GET16 (src, 0), \ + __extension__ __STRING2_SMALL_GET16 (src, 4), \ + __extension__ __STRING2_SMALL_GET32 (src, 0), \ + __extension__ __STRING2_SMALL_GET32 (src, 4) +# endif +__STRING_INLINE void *__mempcpy_small (void *, char, char, char, char, + __uint16_t, __uint16_t, __uint32_t, + __uint32_t, size_t); +__STRING_INLINE void * +__mempcpy_small (void *__dest1, + char __src0_1, char __src2_1, char __src4_1, char __src6_1, + __uint16_t __src0_2, __uint16_t __src4_2, + __uint32_t __src0_4, __uint32_t __src4_4, + size_t __srclen) +{ + union { + __uint32_t __ui; + __uint16_t __usi; + unsigned char __uc; + unsigned char __c; + } *__u = __dest1; + switch ((unsigned int) __srclen) + { + case 1: + __u->__c = __src0_1; + __u = __extension__ ((void *) __u + 1); + break; + case 2: + __u->__usi = __src0_2; + __u = __extension__ ((void *) __u + 2); + break; + case 3: + __u->__usi = __src0_2; + __u = __extension__ ((void *) __u + 2); + __u->__c = __src2_1; + __u = __extension__ ((void *) __u + 1); + break; + case 4: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + break; + case 5: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__c = __src4_1; + __u = __extension__ ((void *) __u + 1); + break; + case 6: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__usi = __src4_2; + __u = __extension__ ((void *) __u + 2); + break; + case 7: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__usi = __src4_2; + __u = __extension__ ((void *) __u + 2); + __u->__c = __src6_1; + __u = __extension__ ((void *) __u + 1); + break; + case 8: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__ui = __src4_4; + __u = __extension__ ((void *) __u + 4); + break; + } + return (void *) __u; +} +# else +# ifndef _FORCE_INLINES +# define __mempcpy_args(src) \ + ((const char *) (src))[0], \ + __extension__ ((__STRING2_COPY_ARR2) \ + { { ((const char *) (src))[0], ((const char *) (src))[1] } }), \ + __extension__ ((__STRING2_COPY_ARR3) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2] } }), \ + __extension__ ((__STRING2_COPY_ARR4) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3] } }), \ + __extension__ ((__STRING2_COPY_ARR5) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4] } }), \ + __extension__ ((__STRING2_COPY_ARR6) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5] } }), \ + __extension__ ((__STRING2_COPY_ARR7) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5], \ + ((const char *) (src))[6] } }), \ + __extension__ ((__STRING2_COPY_ARR8) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5], \ + ((const char *) (src))[6], ((const char *) (src))[7] } }) +# endif +__STRING_INLINE void *__mempcpy_small (void *, char, __STRING2_COPY_ARR2, + __STRING2_COPY_ARR3, + __STRING2_COPY_ARR4, + __STRING2_COPY_ARR5, + __STRING2_COPY_ARR6, + __STRING2_COPY_ARR7, + __STRING2_COPY_ARR8, size_t); +__STRING_INLINE void * +__mempcpy_small (void *__dest, char __src1, + __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, + __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, + __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, + __STRING2_COPY_ARR8 __src8, size_t __srclen) +{ + union { + char __c; + __STRING2_COPY_ARR2 __sca2; + __STRING2_COPY_ARR3 __sca3; + __STRING2_COPY_ARR4 __sca4; + __STRING2_COPY_ARR5 __sca5; + __STRING2_COPY_ARR6 __sca6; + __STRING2_COPY_ARR7 __sca7; + __STRING2_COPY_ARR8 __sca8; + } *__u = __dest; + switch ((unsigned int) __srclen) + { + case 1: + __u->__c = __src1; + break; + case 2: + __extension__ __u->__sca2 = __src2; + break; + case 3: + __extension__ __u->__sca3 = __src3; + break; + case 4: + __extension__ __u->__sca4 = __src4; + break; + case 5: + __extension__ __u->__sca5 = __src5; + break; + case 6: + __extension__ __u->__sca6 = __src6; + break; + case 7: + __extension__ __u->__sca7 = __src7; + break; + case 8: + __extension__ __u->__sca8 = __src8; + break; + } + return __extension__ ((void *) __u + __srclen); +} +# endif +# endif +# endif +#endif + + +/* Return pointer to C in S. */ +#ifndef _HAVE_STRING_ARCH_strchr +extern void *__rawmemchr (const void *__s, int __c); +# if __GNUC_PREREQ (3, 2) +# define strchr(s, c) \ + (__extension__ (__builtin_constant_p (c) && !__builtin_constant_p (s) \ + && (c) == '\0' \ + ? (char *) __rawmemchr (s, c) \ + : __builtin_strchr (s, c))) +# else +# define strchr(s, c) \ + (__extension__ (__builtin_constant_p (c) && (c) == '\0' \ + ? (char *) __rawmemchr (s, c) \ + : strchr (s, c))) +# endif +#endif + + +/* Copy SRC to DEST. */ +#if (!defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0)) \ + || defined _FORCE_INLINES +# if !defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0) +# define strcpy(dest, src) \ + (__extension__ (__builtin_constant_p (src) \ + ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ + ? __strcpy_small (dest, __strcpy_args (src), \ + strlen (src) + 1) \ + : (char *) memcpy (dest, src, strlen (src) + 1)) \ + : strcpy (dest, src))) +# endif + +# if _STRING_ARCH_unaligned +# ifndef _FORCE_INLINES +# define __strcpy_args(src) \ + __extension__ __STRING2_SMALL_GET16 (src, 0), \ + __extension__ __STRING2_SMALL_GET16 (src, 4), \ + __extension__ __STRING2_SMALL_GET32 (src, 0), \ + __extension__ __STRING2_SMALL_GET32 (src, 4) +# endif +__STRING_INLINE char *__strcpy_small (char *, __uint16_t, __uint16_t, + __uint32_t, __uint32_t, size_t); +__STRING_INLINE char * +__strcpy_small (char *__dest, + __uint16_t __src0_2, __uint16_t __src4_2, + __uint32_t __src0_4, __uint32_t __src4_4, + size_t __srclen) +{ + union { + __uint32_t __ui; + __uint16_t __usi; + unsigned char __uc; + } *__u = (void *) __dest; + switch ((unsigned int) __srclen) + { + case 1: + __u->__uc = '\0'; + break; + case 2: + __u->__usi = __src0_2; + break; + case 3: + __u->__usi = __src0_2; + __u = __extension__ ((void *) __u + 2); + __u->__uc = '\0'; + break; + case 4: + __u->__ui = __src0_4; + break; + case 5: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__uc = '\0'; + break; + case 6: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__usi = __src4_2; + break; + case 7: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__usi = __src4_2; + __u = __extension__ ((void *) __u + 2); + __u->__uc = '\0'; + break; + case 8: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__ui = __src4_4; + break; + } + return __dest; +} +# else +# ifndef _FORCE_INLINES +# define __strcpy_args(src) \ + __extension__ ((__STRING2_COPY_ARR2) \ + { { ((const char *) (src))[0], '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR3) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR4) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR5) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR6) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR7) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5], \ + '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR8) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5], \ + ((const char *) (src))[6], '\0' } }) +# endif +__STRING_INLINE char *__strcpy_small (char *, __STRING2_COPY_ARR2, + __STRING2_COPY_ARR3, + __STRING2_COPY_ARR4, + __STRING2_COPY_ARR5, + __STRING2_COPY_ARR6, + __STRING2_COPY_ARR7, + __STRING2_COPY_ARR8, size_t); +__STRING_INLINE char * +__strcpy_small (char *__dest, + __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, + __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, + __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, + __STRING2_COPY_ARR8 __src8, size_t __srclen) +{ + union { + char __c; + __STRING2_COPY_ARR2 __sca2; + __STRING2_COPY_ARR3 __sca3; + __STRING2_COPY_ARR4 __sca4; + __STRING2_COPY_ARR5 __sca5; + __STRING2_COPY_ARR6 __sca6; + __STRING2_COPY_ARR7 __sca7; + __STRING2_COPY_ARR8 __sca8; + } *__u = (void *) __dest; + switch ((unsigned int) __srclen) + { + case 1: + __u->__c = '\0'; + break; + case 2: + __extension__ __u->__sca2 = __src2; + break; + case 3: + __extension__ __u->__sca3 = __src3; + break; + case 4: + __extension__ __u->__sca4 = __src4; + break; + case 5: + __extension__ __u->__sca5 = __src5; + break; + case 6: + __extension__ __u->__sca6 = __src6; + break; + case 7: + __extension__ __u->__sca7 = __src7; + break; + case 8: + __extension__ __u->__sca8 = __src8; + break; + } + return __dest; +} +# endif +#endif + + +/* Copy SRC to DEST, returning pointer to final NUL byte. */ +#ifdef __USE_GNU +# if !defined _HAVE_STRING_ARCH_stpcpy || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_stpcpy +# if __GNUC_PREREQ (3, 4) +# define __stpcpy(dest, src) __builtin_stpcpy (dest, src) +# elif __GNUC_PREREQ (3, 0) +# define __stpcpy(dest, src) \ + (__extension__ (__builtin_constant_p (src) \ + ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ + ? __builtin_strcpy (dest, src) + strlen (src) \ + : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) \ + - 1)) \ + : __stpcpy (dest, src))) +# else +# define __stpcpy(dest, src) \ + (__extension__ (__builtin_constant_p (src) \ + ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ + ? __stpcpy_small (dest, __stpcpy_args (src), \ + strlen (src) + 1) \ + : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) \ + - 1)) \ + : __stpcpy (dest, src))) +# endif +/* In glibc we use this function frequently but for namespace reasons + we have to use the name `__stpcpy'. */ +# define stpcpy(dest, src) __stpcpy (dest, src) +# endif + +# if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES +# if _STRING_ARCH_unaligned +# ifndef _FORCE_INLINES +# define __stpcpy_args(src) \ + __extension__ __STRING2_SMALL_GET16 (src, 0), \ + __extension__ __STRING2_SMALL_GET16 (src, 4), \ + __extension__ __STRING2_SMALL_GET32 (src, 0), \ + __extension__ __STRING2_SMALL_GET32 (src, 4) +# endif +__STRING_INLINE char *__stpcpy_small (char *, __uint16_t, __uint16_t, + __uint32_t, __uint32_t, size_t); +__STRING_INLINE char * +__stpcpy_small (char *__dest, + __uint16_t __src0_2, __uint16_t __src4_2, + __uint32_t __src0_4, __uint32_t __src4_4, + size_t __srclen) +{ + union { + unsigned int __ui; + unsigned short int __usi; + unsigned char __uc; + char __c; + } *__u = (void *) __dest; + switch ((unsigned int) __srclen) + { + case 1: + __u->__uc = '\0'; + break; + case 2: + __u->__usi = __src0_2; + __u = __extension__ ((void *) __u + 1); + break; + case 3: + __u->__usi = __src0_2; + __u = __extension__ ((void *) __u + 2); + __u->__uc = '\0'; + break; + case 4: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 3); + break; + case 5: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__uc = '\0'; + break; + case 6: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__usi = __src4_2; + __u = __extension__ ((void *) __u + 1); + break; + case 7: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__usi = __src4_2; + __u = __extension__ ((void *) __u + 2); + __u->__uc = '\0'; + break; + case 8: + __u->__ui = __src0_4; + __u = __extension__ ((void *) __u + 4); + __u->__ui = __src4_4; + __u = __extension__ ((void *) __u + 3); + break; + } + return &__u->__c; +} +# else +# ifndef _FORCE_INLINES +# define __stpcpy_args(src) \ + __extension__ ((__STRING2_COPY_ARR2) \ + { { ((const char *) (src))[0], '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR3) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR4) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR5) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR6) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR7) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5], \ + '\0' } }), \ + __extension__ ((__STRING2_COPY_ARR8) \ + { { ((const char *) (src))[0], ((const char *) (src))[1], \ + ((const char *) (src))[2], ((const char *) (src))[3], \ + ((const char *) (src))[4], ((const char *) (src))[5], \ + ((const char *) (src))[6], '\0' } }) +# endif +__STRING_INLINE char *__stpcpy_small (char *, __STRING2_COPY_ARR2, + __STRING2_COPY_ARR3, + __STRING2_COPY_ARR4, + __STRING2_COPY_ARR5, + __STRING2_COPY_ARR6, + __STRING2_COPY_ARR7, + __STRING2_COPY_ARR8, size_t); +__STRING_INLINE char * +__stpcpy_small (char *__dest, + __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, + __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, + __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, + __STRING2_COPY_ARR8 __src8, size_t __srclen) +{ + union { + char __c; + __STRING2_COPY_ARR2 __sca2; + __STRING2_COPY_ARR3 __sca3; + __STRING2_COPY_ARR4 __sca4; + __STRING2_COPY_ARR5 __sca5; + __STRING2_COPY_ARR6 __sca6; + __STRING2_COPY_ARR7 __sca7; + __STRING2_COPY_ARR8 __sca8; + } *__u = (void *) __dest; + switch ((unsigned int) __srclen) + { + case 1: + __u->__c = '\0'; + break; + case 2: + __extension__ __u->__sca2 = __src2; + break; + case 3: + __extension__ __u->__sca3 = __src3; + break; + case 4: + __extension__ __u->__sca4 = __src4; + break; + case 5: + __extension__ __u->__sca5 = __src5; + break; + case 6: + __extension__ __u->__sca6 = __src6; + break; + case 7: + __extension__ __u->__sca7 = __src7; + break; + case 8: + __extension__ __u->__sca8 = __src8; + break; + } + return __dest + __srclen - 1; +} +# endif +# endif +# endif +#endif + + +/* Copy no more than N characters of SRC to DEST. */ +#ifndef _HAVE_STRING_ARCH_strncpy +# if __GNUC_PREREQ (3, 2) +# define strncpy(dest, src, n) __builtin_strncpy (dest, src, n) +# else +# define strncpy(dest, src, n) \ + (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ + ? (strlen (src) + 1 >= ((size_t) (n)) \ + ? (char *) memcpy (dest, src, n) \ + : strncpy (dest, src, n)) \ + : strncpy (dest, src, n))) +# endif +#endif + + +/* Append no more than N characters from SRC onto DEST. */ +#ifndef _HAVE_STRING_ARCH_strncat +# ifdef _USE_STRING_ARCH_strchr +# define strncat(dest, src, n) \ + (__extension__ ({ char *__dest = (dest); \ + __builtin_constant_p (src) && __builtin_constant_p (n) \ + ? (strlen (src) < ((size_t) (n)) \ + ? strcat (__dest, src) \ + : (*((char *) __mempcpy (strchr (__dest, '\0'), \ + src, n)) = '\0', __dest)) \ + : strncat (dest, src, n); })) +# elif __GNUC_PREREQ (3, 2) +# define strncat(dest, src, n) __builtin_strncat (dest, src, n) +# else +# define strncat(dest, src, n) \ + (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ + ? (strlen (src) < ((size_t) (n)) \ + ? strcat (dest, src) \ + : strncat (dest, src, n)) \ + : strncat (dest, src, n))) +# endif +#endif + + +/* Compare characters of S1 and S2. */ +#ifndef _HAVE_STRING_ARCH_strcmp +# if __GNUC_PREREQ (3, 2) +# define strcmp(s1, s2) \ + __extension__ \ + ({ size_t __s1_len, __s2_len; \ + (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ + && (__s1_len = strlen (s1), __s2_len = strlen (s2), \ + (!__string2_1bptr_p (s1) || __s1_len >= 4) \ + && (!__string2_1bptr_p (s2) || __s2_len >= 4)) \ + ? __builtin_strcmp (s1, s2) \ + : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ + && (__s1_len = strlen (s1), __s1_len < 4) \ + ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ + ? __builtin_strcmp (s1, s2) \ + : __strcmp_cg (s1, s2, __s1_len)) \ + : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ + && (__s2_len = strlen (s2), __s2_len < 4) \ + ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ + ? __builtin_strcmp (s1, s2) \ + : __strcmp_gc (s1, s2, __s2_len)) \ + : __builtin_strcmp (s1, s2)))); }) +# else +# define strcmp(s1, s2) \ + __extension__ \ + ({ size_t __s1_len, __s2_len; \ + (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ + && (__s1_len = strlen (s1), __s2_len = strlen (s2), \ + (!__string2_1bptr_p (s1) || __s1_len >= 4) \ + && (!__string2_1bptr_p (s2) || __s2_len >= 4)) \ + ? memcmp ((const char *) (s1), (const char *) (s2), \ + (__s1_len < __s2_len ? __s1_len : __s2_len) + 1) \ + : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ + && (__s1_len = strlen (s1), __s1_len < 4) \ + ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ + ? __strcmp_cc (s1, s2, __s1_len) \ + : __strcmp_cg (s1, s2, __s1_len)) \ + : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ + && (__s2_len = strlen (s2), __s2_len < 4) \ + ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ + ? __strcmp_cc (s1, s2, __s2_len) \ + : __strcmp_gc (s1, s2, __s2_len)) \ + : strcmp (s1, s2)))); }) +# endif + +# define __strcmp_cc(s1, s2, l) \ + (__extension__ ({ int __result = \ + (((const unsigned char *) (const char *) (s1))[0] \ + - ((const unsigned char *) (const char *)(s2))[0]); \ + if (l > 0 && __result == 0) \ + { \ + __result = (((const unsigned char *) \ + (const char *) (s1))[1] \ + - ((const unsigned char *) \ + (const char *) (s2))[1]); \ + if (l > 1 && __result == 0) \ + { \ + __result = \ + (((const unsigned char *) \ + (const char *) (s1))[2] \ + - ((const unsigned char *) \ + (const char *) (s2))[2]); \ + if (l > 2 && __result == 0) \ + __result = \ + (((const unsigned char *) \ + (const char *) (s1))[3] \ + - ((const unsigned char *) \ + (const char *) (s2))[3]); \ + } \ + } \ + __result; })) + +# define __strcmp_cg(s1, s2, l1) \ + (__extension__ ({ const unsigned char *__s2 = \ + (const unsigned char *) (const char *) (s2); \ + int __result = \ + (((const unsigned char *) (const char *) (s1))[0] \ + - __s2[0]); \ + if (l1 > 0 && __result == 0) \ + { \ + __result = (((const unsigned char *) \ + (const char *) (s1))[1] - __s2[1]); \ + if (l1 > 1 && __result == 0) \ + { \ + __result = (((const unsigned char *) \ + (const char *) (s1))[2] - __s2[2]); \ + if (l1 > 2 && __result == 0) \ + __result = (((const unsigned char *) \ + (const char *) (s1))[3] \ + - __s2[3]); \ + } \ + } \ + __result; })) + +# define __strcmp_gc(s1, s2, l2) (- __strcmp_cg (s2, s1, l2)) +#endif + + +/* Compare N characters of S1 and S2. */ +#ifndef _HAVE_STRING_ARCH_strncmp +# define strncmp(s1, s2, n) \ + (__extension__ (__builtin_constant_p (n) \ + && ((__builtin_constant_p (s1) \ + && strlen (s1) < ((size_t) (n))) \ + || (__builtin_constant_p (s2) \ + && strlen (s2) < ((size_t) (n)))) \ + ? strcmp (s1, s2) : strncmp (s1, s2, n))) +#endif + + +/* Return the length of the initial segment of S which + consists entirely of characters not in REJECT. */ +#if !defined _HAVE_STRING_ARCH_strcspn || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_strcspn +# if __GNUC_PREREQ (3, 2) +# define strcspn(s, reject) \ + __extension__ \ + ({ char __r0, __r1, __r2; \ + (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ + ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ + ? __builtin_strcspn (s, reject) \ + : ((__r0 = ((const char *) (reject))[0], __r0 == '\0') \ + ? strlen (s) \ + : ((__r1 = ((const char *) (reject))[1], __r1 == '\0') \ + ? __strcspn_c1 (s, __r0) \ + : ((__r2 = ((const char *) (reject))[2], __r2 == '\0') \ + ? __strcspn_c2 (s, __r0, __r1) \ + : (((const char *) (reject))[3] == '\0' \ + ? __strcspn_c3 (s, __r0, __r1, __r2) \ + : __builtin_strcspn (s, reject)))))) \ + : __builtin_strcspn (s, reject)); }) +# else +# define strcspn(s, reject) \ + __extension__ \ + ({ char __r0, __r1, __r2; \ + (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ + ? ((__r0 = ((const char *) (reject))[0], __r0 == '\0') \ + ? strlen (s) \ + : ((__r1 = ((const char *) (reject))[1], __r1 == '\0') \ + ? __strcspn_c1 (s, __r0) \ + : ((__r2 = ((const char *) (reject))[2], __r2 == '\0') \ + ? __strcspn_c2 (s, __r0, __r1) \ + : (((const char *) (reject))[3] == '\0' \ + ? __strcspn_c3 (s, __r0, __r1, __r2) \ + : strcspn (s, reject))))) \ + : strcspn (s, reject)); }) +# endif +# endif + +__STRING_INLINE size_t __strcspn_c1 (const char *__s, int __reject); +__STRING_INLINE size_t +__strcspn_c1 (const char *__s, int __reject) +{ + size_t __result = 0; + while (__s[__result] != '\0' && __s[__result] != __reject) + ++__result; + return __result; +} + +__STRING_INLINE size_t __strcspn_c2 (const char *__s, int __reject1, + int __reject2); +__STRING_INLINE size_t +__strcspn_c2 (const char *__s, int __reject1, int __reject2) +{ + size_t __result = 0; + while (__s[__result] != '\0' && __s[__result] != __reject1 + && __s[__result] != __reject2) + ++__result; + return __result; +} + +__STRING_INLINE size_t __strcspn_c3 (const char *__s, int __reject1, + int __reject2, int __reject3); +__STRING_INLINE size_t +__strcspn_c3 (const char *__s, int __reject1, int __reject2, + int __reject3) +{ + size_t __result = 0; + while (__s[__result] != '\0' && __s[__result] != __reject1 + && __s[__result] != __reject2 && __s[__result] != __reject3) + ++__result; + return __result; +} +#endif + + +/* Return the length of the initial segment of S which + consists entirely of characters in ACCEPT. */ +#if !defined _HAVE_STRING_ARCH_strspn || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_strspn +# if __GNUC_PREREQ (3, 2) +# define strspn(s, accept) \ + __extension__ \ + ({ char __a0, __a1, __a2; \ + (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ + ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ + ? __builtin_strspn (s, accept) \ + : ((__a0 = ((const char *) (accept))[0], __a0 == '\0') \ + ? ((void) (s), (size_t) 0) \ + : ((__a1 = ((const char *) (accept))[1], __a1 == '\0') \ + ? __strspn_c1 (s, __a0) \ + : ((__a2 = ((const char *) (accept))[2], __a2 == '\0') \ + ? __strspn_c2 (s, __a0, __a1) \ + : (((const char *) (accept))[3] == '\0' \ + ? __strspn_c3 (s, __a0, __a1, __a2) \ + : __builtin_strspn (s, accept)))))) \ + : __builtin_strspn (s, accept)); }) +# else +# define strspn(s, accept) \ + __extension__ \ + ({ char __a0, __a1, __a2; \ + (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ + ? ((__a0 = ((const char *) (accept))[0], __a0 == '\0') \ + ? ((void) (s), (size_t) 0) \ + : ((__a1 = ((const char *) (accept))[1], __a1 == '\0') \ + ? __strspn_c1 (s, __a0) \ + : ((__a2 = ((const char *) (accept))[2], __a2 == '\0') \ + ? __strspn_c2 (s, __a0, __a1) \ + : (((const char *) (accept))[3] == '\0' \ + ? __strspn_c3 (s, __a0, __a1, __a2) \ + : strspn (s, accept))))) \ + : strspn (s, accept)); }) +# endif +# endif + +__STRING_INLINE size_t __strspn_c1 (const char *__s, int __accept); +__STRING_INLINE size_t +__strspn_c1 (const char *__s, int __accept) +{ + size_t __result = 0; + /* Please note that __accept never can be '\0'. */ + while (__s[__result] == __accept) + ++__result; + return __result; +} + +__STRING_INLINE size_t __strspn_c2 (const char *__s, int __accept1, + int __accept2); +__STRING_INLINE size_t +__strspn_c2 (const char *__s, int __accept1, int __accept2) +{ + size_t __result = 0; + /* Please note that __accept1 and __accept2 never can be '\0'. */ + while (__s[__result] == __accept1 || __s[__result] == __accept2) + ++__result; + return __result; +} + +__STRING_INLINE size_t __strspn_c3 (const char *__s, int __accept1, + int __accept2, int __accept3); +__STRING_INLINE size_t +__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3) +{ + size_t __result = 0; + /* Please note that __accept1 to __accept3 never can be '\0'. */ + while (__s[__result] == __accept1 || __s[__result] == __accept2 + || __s[__result] == __accept3) + ++__result; + return __result; +} +#endif + + +/* Find the first occurrence in S of any character in ACCEPT. */ +#if !defined _HAVE_STRING_ARCH_strpbrk || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_strpbrk +# if __GNUC_PREREQ (3, 2) +# define strpbrk(s, accept) \ + __extension__ \ + ({ char __a0, __a1, __a2; \ + (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ + ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ + ? __builtin_strpbrk (s, accept) \ + : ((__a0 = ((const char *) (accept))[0], __a0 == '\0') \ + ? ((void) (s), (char *) NULL) \ + : ((__a1 = ((const char *) (accept))[1], __a1 == '\0') \ + ? __builtin_strchr (s, __a0) \ + : ((__a2 = ((const char *) (accept))[2], __a2 == '\0') \ + ? __strpbrk_c2 (s, __a0, __a1) \ + : (((const char *) (accept))[3] == '\0' \ + ? __strpbrk_c3 (s, __a0, __a1, __a2) \ + : __builtin_strpbrk (s, accept)))))) \ + : __builtin_strpbrk (s, accept)); }) +# else +# define strpbrk(s, accept) \ + __extension__ \ + ({ char __a0, __a1, __a2; \ + (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ + ? ((__a0 = ((const char *) (accept))[0], __a0 == '\0') \ + ? ((void) (s), (char *) NULL) \ + : ((__a1 = ((const char *) (accept))[1], __a1 == '\0') \ + ? strchr (s, __a0) \ + : ((__a2 = ((const char *) (accept))[2], __a2 == '\0') \ + ? __strpbrk_c2 (s, __a0, __a1) \ + : (((const char *) (accept))[3] == '\0' \ + ? __strpbrk_c3 (s, __a0, __a1, __a2) \ + : strpbrk (s, accept))))) \ + : strpbrk (s, accept)); }) +# endif +# endif + +__STRING_INLINE char *__strpbrk_c2 (const char *__s, int __accept1, + int __accept2); +__STRING_INLINE char * +__strpbrk_c2 (const char *__s, int __accept1, int __accept2) +{ + /* Please note that __accept1 and __accept2 never can be '\0'. */ + while (*__s != '\0' && *__s != __accept1 && *__s != __accept2) + ++__s; + return *__s == '\0' ? NULL : (char *) (size_t) __s; +} + +__STRING_INLINE char *__strpbrk_c3 (const char *__s, int __accept1, + int __accept2, int __accept3); +__STRING_INLINE char * +__strpbrk_c3 (const char *__s, int __accept1, int __accept2, int __accept3) +{ + /* Please note that __accept1 to __accept3 never can be '\0'. */ + while (*__s != '\0' && *__s != __accept1 && *__s != __accept2 + && *__s != __accept3) + ++__s; + return *__s == '\0' ? NULL : (char *) (size_t) __s; +} +#endif + + +/* Find the first occurrence of NEEDLE in HAYSTACK. Newer gcc versions + do this itself. */ +#if !defined _HAVE_STRING_ARCH_strstr && !__GNUC_PREREQ (2, 97) +# define strstr(haystack, needle) \ + (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \ + ? (((const char *) (needle))[0] == '\0' \ + ? (char *) (size_t) (haystack) \ + : (((const char *) (needle))[1] == '\0' \ + ? strchr (haystack, \ + ((const char *) (needle))[0]) \ + : strstr (haystack, needle))) \ + : strstr (haystack, needle))) +#endif + + +#if !defined _HAVE_STRING_ARCH_strtok_r || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_strtok_r +# define __strtok_r(s, sep, nextp) \ + (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep) \ + && ((const char *) (sep))[0] != '\0' \ + && ((const char *) (sep))[1] == '\0' \ + ? __strtok_r_1c (s, ((const char *) (sep))[0], nextp) \ + : __strtok_r (s, sep, nextp))) +# endif + +__STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp); +__STRING_INLINE char * +__strtok_r_1c (char *__s, char __sep, char **__nextp) +{ + char *__result; + if (__s == NULL) + __s = *__nextp; + while (*__s == __sep) + ++__s; + __result = NULL; + if (*__s != '\0') + { + __result = __s++; + while (*__s != '\0') + if (*__s++ == __sep) + { + __s[-1] = '\0'; + break; + } + } + *__nextp = __s; + return __result; +} +# ifdef __USE_POSIX +# define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp) +# endif +#endif + + +#if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES +# ifndef _HAVE_STRING_ARCH_strsep + +extern char *__strsep_g (char **__stringp, const char *__delim); +# define __strsep(s, reject) \ + __extension__ \ + ({ char __r0, __r1, __r2; \ + (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ + && (__r0 = ((const char *) (reject))[0], \ + ((const char *) (reject))[0] != '\0') \ + ? ((__r1 = ((const char *) (reject))[1], \ + ((const char *) (reject))[1] == '\0') \ + ? __strsep_1c (s, __r0) \ + : ((__r2 = ((const char *) (reject))[2], __r2 == '\0') \ + ? __strsep_2c (s, __r0, __r1) \ + : (((const char *) (reject))[3] == '\0' \ + ? __strsep_3c (s, __r0, __r1, __r2) \ + : __strsep_g (s, reject)))) \ + : __strsep_g (s, reject)); }) +# endif + +__STRING_INLINE char *__strsep_1c (char **__s, char __reject); +__STRING_INLINE char * +__strsep_1c (char **__s, char __reject) +{ + char *__retval = *__s; + if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL) + *(*__s)++ = '\0'; + return __retval; +} + +__STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2); +__STRING_INLINE char * +__strsep_2c (char **__s, char __reject1, char __reject2) +{ + char *__retval = *__s; + if (__retval != NULL) + { + char *__cp = __retval; + while (1) + { + if (*__cp == '\0') + { + __cp = NULL; + break; + } + if (*__cp == __reject1 || *__cp == __reject2) + { + *__cp++ = '\0'; + break; + } + ++__cp; + } + *__s = __cp; + } + return __retval; +} + +__STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2, + char __reject3); +__STRING_INLINE char * +__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3) +{ + char *__retval = *__s; + if (__retval != NULL) + { + char *__cp = __retval; + while (1) + { + if (*__cp == '\0') + { + __cp = NULL; + break; + } + if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3) + { + *__cp++ = '\0'; + break; + } + ++__cp; + } + *__s = __cp; + } + return __retval; +} +# ifdef __USE_MISC +# define strsep(s, reject) __strsep (s, reject) +# endif +#endif + +/* We need the memory allocation functions for inline strdup(). + Referring to stdlib.h (even minimally) is not allowed + in any of the tight standards compliant modes. */ +#ifdef __USE_MISC + +# if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup +# define __need_malloc_and_calloc +# include +# endif + +# ifndef _HAVE_STRING_ARCH_strdup + +extern char *__strdup (const char *__string) __THROW __attribute_malloc__; +# define __strdup(s) \ + (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) \ + ? (((const char *) (s))[0] == '\0' \ + ? (char *) calloc ((size_t) 1, (size_t) 1) \ + : ({ size_t __len = strlen (s) + 1; \ + char *__retval = (char *) malloc (__len); \ + if (__retval != NULL) \ + __retval = (char *) memcpy (__retval, s, __len); \ + __retval; })) \ + : __strdup (s))) + +# if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 +# define strdup(s) __strdup (s) +# endif +# endif + +# ifndef _HAVE_STRING_ARCH_strndup + +extern char *__strndup (const char *__string, size_t __n) + __THROW __attribute_malloc__; +# define __strndup(s, n) \ + (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) \ + ? (((const char *) (s))[0] == '\0' \ + ? (char *) calloc ((size_t) 1, (size_t) 1) \ + : ({ size_t __len = strlen (s) + 1; \ + size_t __n = (n); \ + char *__retval; \ + if (__n < __len) \ + __len = __n + 1; \ + __retval = (char *) malloc (__len); \ + if (__retval != NULL) \ + { \ + __retval[__len - 1] = '\0'; \ + __retval = (char *) memcpy (__retval, s, \ + __len - 1); \ + } \ + __retval; })) \ + : __strndup (s, n))) + +# ifdef __USE_XOPEN2K8 +# define strndup(s, n) __strndup (s, n) +# endif +# endif + +#endif /* Use misc. or use GNU. */ + +#ifndef _FORCE_INLINES +# undef __STRING_INLINE +#endif + +#endif /* No string inlines. */ diff --git a/libktorrent/miniboost/bits/string3.h b/libktorrent/miniboost/bits/string3.h new file mode 100644 index 00000000..76060903 --- /dev/null +++ b/libktorrent/miniboost/bits/string3.h @@ -0,0 +1,151 @@ +/* Copyright (C) 2004-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STRING_H +# error "Never use directly; include instead." +#endif + +__warndecl (__warn_memset_zero_len, + "memset used with constant zero length parameter; this could be due to transposed parameters"); + +#ifndef __cplusplus +/* XXX This is temporarily. We should not redefine any of the symbols + and instead integrate the error checking into the original + definitions. */ +# undef memcpy +# undef memmove +# undef memset +# undef strcat +# undef strcpy +# undef strncat +# undef strncpy +# ifdef __USE_GNU +# undef mempcpy +# undef stpcpy +# endif +# ifdef __USE_MISC +# undef bcopy +# undef bzero +# endif +#endif + + +__fortify_function void * +__NTH (memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __len)) +{ + return __builtin___memcpy_chk (__dest, __src, __len, __bos0 (__dest)); +} + +__fortify_function void * +__NTH (memmove (void *__dest, const void *__src, size_t __len)) +{ + return __builtin___memmove_chk (__dest, __src, __len, __bos0 (__dest)); +} + +#ifdef __USE_GNU +__fortify_function void * +__NTH (mempcpy (void *__restrict __dest, const void *__restrict __src, + size_t __len)) +{ + return __builtin___mempcpy_chk (__dest, __src, __len, __bos0 (__dest)); +} +#endif + + +/* The first two tests here help to catch a somewhat common problem + where the second and third parameter are transposed. This is + especially problematic if the intended fill value is zero. In this + case no work is done at all. We detect these problems by referring + non-existing functions. */ +__fortify_function void * +__NTH (memset (void *__dest, int __ch, size_t __len)) +{ + if (__builtin_constant_p (__len) && __len == 0 + && (!__builtin_constant_p (__ch) || __ch != 0)) + { + __warn_memset_zero_len (); + return __dest; + } + return __builtin___memset_chk (__dest, __ch, __len, __bos0 (__dest)); +} + +#ifdef __USE_MISC +__fortify_function void +__NTH (bcopy (const void *__src, void *__dest, size_t __len)) +{ + (void) __builtin___memmove_chk (__dest, __src, __len, __bos0 (__dest)); +} + +__fortify_function void +__NTH (bzero (void *__dest, size_t __len)) +{ + (void) __builtin___memset_chk (__dest, '\0', __len, __bos0 (__dest)); +} +#endif + +__fortify_function char * +__NTH (strcpy (char *__restrict __dest, const char *__restrict __src)) +{ + return __builtin___strcpy_chk (__dest, __src, __bos (__dest)); +} + +#ifdef __USE_GNU +__fortify_function char * +__NTH (stpcpy (char *__restrict __dest, const char *__restrict __src)) +{ + return __builtin___stpcpy_chk (__dest, __src, __bos (__dest)); +} +#endif + + +__fortify_function char * +__NTH (strncpy (char *__restrict __dest, const char *__restrict __src, + size_t __len)) +{ + return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest)); +} + +// XXX We have no corresponding builtin yet. +extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n, + size_t __destlen) __THROW; +extern char *__REDIRECT_NTH (__stpncpy_alias, (char *__dest, const char *__src, + size_t __n), stpncpy); + +__fortify_function char * +__NTH (stpncpy (char *__dest, const char *__src, size_t __n)) +{ + if (__bos (__dest) != (size_t) -1 + && (!__builtin_constant_p (__n) || __n <= __bos (__dest))) + return __stpncpy_chk (__dest, __src, __n, __bos (__dest)); + return __stpncpy_alias (__dest, __src, __n); +} + + +__fortify_function char * +__NTH (strcat (char *__restrict __dest, const char *__restrict __src)) +{ + return __builtin___strcat_chk (__dest, __src, __bos (__dest)); +} + + +__fortify_function char * +__NTH (strncat (char *__restrict __dest, const char *__restrict __src, + size_t __len)) +{ + return __builtin___strncat_chk (__dest, __src, __len, __bos (__dest)); +} diff --git a/libktorrent/miniboost/bits/sys_errlist.h b/libktorrent/miniboost/bits/sys_errlist.h new file mode 100644 index 00000000..4f4b9862 --- /dev/null +++ b/libktorrent/miniboost/bits/sys_errlist.h @@ -0,0 +1,32 @@ +/* Declare sys_errlist and sys_nerr, or don't. Compatibility (do) version. + Copyright (C) 2002-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _STDIO_H +# error "Never include directly; use instead." +#endif + +/* sys_errlist and sys_nerr are deprecated. Use strerror instead. */ + +#ifdef __USE_MISC +extern int sys_nerr; +extern const char *const sys_errlist[]; +#endif +#ifdef __USE_GNU +extern int _sys_nerr; +extern const char *const _sys_errlist[]; +#endif diff --git a/libktorrent/miniboost/bits/time.h b/libktorrent/miniboost/bits/time.h new file mode 100644 index 00000000..10805475 --- /dev/null +++ b/libktorrent/miniboost/bits/time.h @@ -0,0 +1,99 @@ +/* System-dependent timing definitions. Linux version. + Copyright (C) 1996-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* + * Never include this file directly; use instead. + */ + +#if defined __need_timeval || defined __USE_GNU +# ifndef _STRUCT_TIMEVAL +# define _STRUCT_TIMEVAL 1 +# include + +/* A time value that is accurate to the nearest + microsecond but also has a range of years. */ +struct timeval + { + __time_t tv_sec; /* Seconds. */ + __suseconds_t tv_usec; /* Microseconds. */ + }; +# endif /* struct timeval */ +#endif + +#ifndef __need_timeval +# ifndef _BITS_TIME_H +# define _BITS_TIME_H 1 + +/* ISO/IEC 9899:1990 7.12.1: + The macro `CLOCKS_PER_SEC' is the number per second of the value + returned by the `clock' function. */ +/* CAE XSH, Issue 4, Version 2: + The value of CLOCKS_PER_SEC is required to be 1 million on all + XSI-conformant systems. */ +# define CLOCKS_PER_SEC 1000000l + +# if (!defined __STRICT_ANSI__ || defined __USE_POSIX) \ + && !defined __USE_XOPEN2K +/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK + presents the real value for clock ticks per second for the system. */ +# include +extern long int __sysconf (int); +# define CLK_TCK ((__clock_t) __sysconf (2)) /* 2 is _SC_CLK_TCK */ +# endif + +# ifdef __USE_POSIX199309 +/* Identifier for system-wide realtime clock. */ +# define CLOCK_REALTIME 0 +/* Monotonic system-wide clock. */ +# define CLOCK_MONOTONIC 1 +/* High-resolution timer from the CPU. */ +# define CLOCK_PROCESS_CPUTIME_ID 2 +/* Thread-specific CPU-time clock. */ +# define CLOCK_THREAD_CPUTIME_ID 3 +/* Monotonic system-wide clock, not adjusted for frequency scaling. */ +# define CLOCK_MONOTONIC_RAW 4 +/* Identifier for system-wide realtime clock, updated only on ticks. */ +# define CLOCK_REALTIME_COARSE 5 +/* Monotonic system-wide clock, updated only on ticks. */ +# define CLOCK_MONOTONIC_COARSE 6 +/* Monotonic system-wide clock that includes time spent in suspension. */ +# define CLOCK_BOOTTIME 7 +/* Like CLOCK_REALTIME but also wakes suspended system. */ +# define CLOCK_REALTIME_ALARM 8 +/* Like CLOCK_BOOTTIME but also wakes suspended system. */ +# define CLOCK_BOOTTIME_ALARM 9 + +/* Flag to indicate time is absolute. */ +# define TIMER_ABSTIME 1 +# endif + +# ifdef __USE_GNU +# include + +__BEGIN_DECLS + +/* Tune a POSIX clock. */ +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __THROW; + +__END_DECLS +# endif /* use GNU */ + +# endif /* bits/time.h */ +#endif + +#undef __need_timeval diff --git a/libktorrent/miniboost/bits/timex.h b/libktorrent/miniboost/bits/timex.h new file mode 100644 index 00000000..ec5b4217 --- /dev/null +++ b/libktorrent/miniboost/bits/timex.h @@ -0,0 +1,108 @@ +/* Copyright (C) 1995-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_TIMEX_H +#define _BITS_TIMEX_H 1 + +#include + +/* These definitions from linux/timex.h as of 2.6.30. */ + +struct timex +{ + unsigned int modes; /* mode selector */ + __syscall_slong_t offset; /* time offset (usec) */ + __syscall_slong_t freq; /* frequency offset (scaled ppm) */ + __syscall_slong_t maxerror; /* maximum error (usec) */ + __syscall_slong_t esterror; /* estimated error (usec) */ + int status; /* clock command/status */ + __syscall_slong_t constant; /* pll time constant */ + __syscall_slong_t precision; /* clock precision (usec) (ro) */ + __syscall_slong_t tolerance; /* clock frequency tolerance (ppm) (ro) */ + struct timeval time; /* (read only) */ + __syscall_slong_t tick; /* (modified) usecs between clock ticks */ + __syscall_slong_t ppsfreq; /* pps frequency (scaled ppm) (ro) */ + __syscall_slong_t jitter; /* pps jitter (us) (ro) */ + int shift; /* interval duration (s) (shift) (ro) */ + __syscall_slong_t stabil; /* pps stability (scaled ppm) (ro) */ + __syscall_slong_t jitcnt; /* jitter limit exceeded (ro) */ + __syscall_slong_t calcnt; /* calibration intervals (ro) */ + __syscall_slong_t errcnt; /* calibration errors (ro) */ + __syscall_slong_t stbcnt; /* stability limit exceeded (ro) */ + + int tai; /* TAI offset (ro) */ + + /* ??? */ + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; +}; + +/* Mode codes (timex.mode) */ +#define ADJ_OFFSET 0x0001 /* time offset */ +#define ADJ_FREQUENCY 0x0002 /* frequency offset */ +#define ADJ_MAXERROR 0x0004 /* maximum time error */ +#define ADJ_ESTERROR 0x0008 /* estimated time error */ +#define ADJ_STATUS 0x0010 /* clock status */ +#define ADJ_TIMECONST 0x0020 /* pll time constant */ +#define ADJ_TAI 0x0080 /* set TAI offset */ +#define ADJ_MICRO 0x1000 /* select microsecond resolution */ +#define ADJ_NANO 0x2000 /* select nanosecond resolution */ +#define ADJ_TICK 0x4000 /* tick value */ +#define ADJ_OFFSET_SINGLESHOT 0x8001 /* old-fashioned adjtime */ +#define ADJ_OFFSET_SS_READ 0xa001 /* read-only adjtime */ + +/* xntp 3.4 compatibility names */ +#define MOD_OFFSET ADJ_OFFSET +#define MOD_FREQUENCY ADJ_FREQUENCY +#define MOD_MAXERROR ADJ_MAXERROR +#define MOD_ESTERROR ADJ_ESTERROR +#define MOD_STATUS ADJ_STATUS +#define MOD_TIMECONST ADJ_TIMECONST +#define MOD_CLKB ADJ_TICK +#define MOD_CLKA ADJ_OFFSET_SINGLESHOT /* 0x8000 in original */ +#define MOD_TAI ADJ_TAI +#define MOD_MICRO ADJ_MICRO +#define MOD_NANO ADJ_NANO + + +/* Status codes (timex.status) */ +#define STA_PLL 0x0001 /* enable PLL updates (rw) */ +#define STA_PPSFREQ 0x0002 /* enable PPS freq discipline (rw) */ +#define STA_PPSTIME 0x0004 /* enable PPS time discipline (rw) */ +#define STA_FLL 0x0008 /* select frequency-lock mode (rw) */ + +#define STA_INS 0x0010 /* insert leap (rw) */ +#define STA_DEL 0x0020 /* delete leap (rw) */ +#define STA_UNSYNC 0x0040 /* clock unsynchronized (rw) */ +#define STA_FREQHOLD 0x0080 /* hold frequency (rw) */ + +#define STA_PPSSIGNAL 0x0100 /* PPS signal present (ro) */ +#define STA_PPSJITTER 0x0200 /* PPS signal jitter exceeded (ro) */ +#define STA_PPSWANDER 0x0400 /* PPS signal wander exceeded (ro) */ +#define STA_PPSERROR 0x0800 /* PPS signal calibration error (ro) */ + +#define STA_CLOCKERR 0x1000 /* clock hardware fault (ro) */ +#define STA_NANO 0x2000 /* resolution (0 = us, 1 = ns) (ro) */ +#define STA_MODE 0x4000 /* mode (0 = PLL, 1 = FLL) (ro) */ +#define STA_CLK 0x8000 /* clock source (0 = A, 1 = B) (ro) */ + +/* Read-only bits */ +#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | \ + STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK) + +#endif /* bits/timex.h */ diff --git a/libktorrent/miniboost/bits/types.h b/libktorrent/miniboost/bits/types.h new file mode 100644 index 00000000..02e1220b --- /dev/null +++ b/libktorrent/miniboost/bits/types.h @@ -0,0 +1,194 @@ +/* bits/types.h -- definitions of __*_t types underlying *_t types. + Copyright (C) 2002-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* + * Never include this file directly; use instead. + */ + +#ifndef _BITS_TYPES_H +#define _BITS_TYPES_H 1 + +#include +#include + +/* Convenience types. */ +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + +/* Fixed-size types, underlying types depend on word size and compiler. */ +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; +#if __WORDSIZE == 64 +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; +#else +__extension__ typedef signed long long int __int64_t; +__extension__ typedef unsigned long long int __uint64_t; +#endif + +/* quad_t is also 64 bits. */ +#if __WORDSIZE == 64 +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; +#else +__extension__ typedef long long int __quad_t; +__extension__ typedef unsigned long long int __u_quad_t; +#endif + + +/* The machine-dependent file defines __*_T_TYPE + macros for each of the OS types we define below. The definitions + of those macros must use the following macros for underlying types. + We define __S_TYPE and __U_TYPE for the signed and unsigned + variants of each of the following integer types on this machine. + + 16 -- "natural" 16-bit type (always short) + 32 -- "natural" 32-bit type (always int) + 64 -- "natural" 64-bit type (long or long long) + LONG32 -- 32-bit type, traditionally long + QUAD -- 64-bit type, always long long + WORD -- natural type of __WORDSIZE bits (int or long) + LONGWORD -- type of __WORDSIZE bits, traditionally long + + We distinguish WORD/LONGWORD, 32/LONG32, and 64/QUAD so that the + conventional uses of `long' or `long long' type modifiers match the + types we define, even when a less-adorned type would be the same size. + This matters for (somewhat) portably writing printf/scanf formats for + these types, where using the appropriate l or ll format modifiers can + make the typedefs and the formats match up across all GNU platforms. If + we used `long' when it's 64 bits where `long long' is expected, then the + compiler would warn about the formats not matching the argument types, + and the programmer changing them to shut up the compiler would break the + program's portability. + + Here we assume what is presently the case in all the GCC configurations + we support: long long is always 64 bits, long is always word/address size, + and int is always 32 bits. */ + +#define __S16_TYPE short int +#define __U16_TYPE unsigned short int +#define __S32_TYPE int +#define __U32_TYPE unsigned int +#define __SLONGWORD_TYPE long int +#define __ULONGWORD_TYPE unsigned long int +#if __WORDSIZE == 32 +# define __SQUAD_TYPE __quad_t +# define __UQUAD_TYPE __u_quad_t +# define __SWORD_TYPE int +# define __UWORD_TYPE unsigned int +# define __SLONG32_TYPE long int +# define __ULONG32_TYPE unsigned long int +# define __S64_TYPE __quad_t +# define __U64_TYPE __u_quad_t +/* We want __extension__ before typedef's that use nonstandard base types + such as `long long' in C89 mode. */ +# define __STD_TYPE __extension__ typedef +#elif __WORDSIZE == 64 +# define __SQUAD_TYPE long int +# define __UQUAD_TYPE unsigned long int +# define __SWORD_TYPE long int +# define __UWORD_TYPE unsigned long int +# define __SLONG32_TYPE int +# define __ULONG32_TYPE unsigned int +# define __S64_TYPE long int +# define __U64_TYPE unsigned long int +/* No need to mark the typedef with __extension__. */ +# define __STD_TYPE typedef +#else +# error +#endif +#include /* Defines __*_T_TYPE macros. */ + + +__STD_TYPE __DEV_T_TYPE __dev_t; /* Type of device numbers. */ +__STD_TYPE __UID_T_TYPE __uid_t; /* Type of user identifications. */ +__STD_TYPE __GID_T_TYPE __gid_t; /* Type of group identifications. */ +__STD_TYPE __INO_T_TYPE __ino_t; /* Type of file serial numbers. */ +__STD_TYPE __INO64_T_TYPE __ino64_t; /* Type of file serial numbers (LFS).*/ +__STD_TYPE __MODE_T_TYPE __mode_t; /* Type of file attribute bitmasks. */ +__STD_TYPE __NLINK_T_TYPE __nlink_t; /* Type of file link counts. */ +__STD_TYPE __OFF_T_TYPE __off_t; /* Type of file sizes and offsets. */ +__STD_TYPE __OFF64_T_TYPE __off64_t; /* Type of file sizes and offsets (LFS). */ +__STD_TYPE __PID_T_TYPE __pid_t; /* Type of process identifications. */ +__STD_TYPE __FSID_T_TYPE __fsid_t; /* Type of file system IDs. */ +__STD_TYPE __CLOCK_T_TYPE __clock_t; /* Type of CPU usage counts. */ +__STD_TYPE __RLIM_T_TYPE __rlim_t; /* Type for resource measurement. */ +__STD_TYPE __RLIM64_T_TYPE __rlim64_t; /* Type for resource measurement (LFS). */ +__STD_TYPE __ID_T_TYPE __id_t; /* General type for IDs. */ +__STD_TYPE __TIME_T_TYPE __time_t; /* Seconds since the Epoch. */ +__STD_TYPE __USECONDS_T_TYPE __useconds_t; /* Count of microseconds. */ +__STD_TYPE __SUSECONDS_T_TYPE __suseconds_t; /* Signed count of microseconds. */ + +__STD_TYPE __DADDR_T_TYPE __daddr_t; /* The type of a disk address. */ +__STD_TYPE __KEY_T_TYPE __key_t; /* Type of an IPC key. */ + +/* Clock ID used in clock and timer functions. */ +__STD_TYPE __CLOCKID_T_TYPE __clockid_t; + +/* Timer ID returned by `timer_create'. */ +__STD_TYPE __TIMER_T_TYPE __timer_t; + +/* Type to represent block size. */ +__STD_TYPE __BLKSIZE_T_TYPE __blksize_t; + +/* Types from the Large File Support interface. */ + +/* Type to count number of disk blocks. */ +__STD_TYPE __BLKCNT_T_TYPE __blkcnt_t; +__STD_TYPE __BLKCNT64_T_TYPE __blkcnt64_t; + +/* Type to count file system blocks. */ +__STD_TYPE __FSBLKCNT_T_TYPE __fsblkcnt_t; +__STD_TYPE __FSBLKCNT64_T_TYPE __fsblkcnt64_t; + +/* Type to count file system nodes. */ +__STD_TYPE __FSFILCNT_T_TYPE __fsfilcnt_t; +__STD_TYPE __FSFILCNT64_T_TYPE __fsfilcnt64_t; + +/* Type of miscellaneous file system fields. */ +__STD_TYPE __FSWORD_T_TYPE __fsword_t; + +__STD_TYPE __SSIZE_T_TYPE __ssize_t; /* Type of a byte count, or error. */ + +/* Signed long type used in system calls. */ +__STD_TYPE __SYSCALL_SLONG_TYPE __syscall_slong_t; +/* Unsigned long type used in system calls. */ +__STD_TYPE __SYSCALL_ULONG_TYPE __syscall_ulong_t; + +/* These few don't really vary by system, they always correspond + to one of the other defined types. */ +typedef __off64_t __loff_t; /* Type of file sizes and offsets (LFS). */ +typedef __quad_t *__qaddr_t; +typedef char *__caddr_t; + +/* Duplicates info from stdint.h but this is used in unistd.h. */ +__STD_TYPE __SWORD_TYPE __intptr_t; + +/* Duplicate info from sys/socket.h. */ +__STD_TYPE __U32_TYPE __socklen_t; + + +#undef __STD_TYPE + +#endif /* bits/types.h */ diff --git a/libktorrent/miniboost/bits/typesizes.h b/libktorrent/miniboost/bits/typesizes.h new file mode 100644 index 00000000..2e0984c8 --- /dev/null +++ b/libktorrent/miniboost/bits/typesizes.h @@ -0,0 +1,89 @@ +/* bits/typesizes.h -- underlying types for *_t. Linux/x86-64 version. + Copyright (C) 2012-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_TYPES_H +# error "Never include directly; use instead." +#endif + +#ifndef _BITS_TYPESIZES_H +#define _BITS_TYPESIZES_H 1 + +/* See for the meaning of these macros. This file exists so + that need not vary across different GNU platforms. */ + +/* X32 kernel interface is 64-bit. */ +#if defined __x86_64__ && defined __ILP32__ +# define __SYSCALL_SLONG_TYPE __SQUAD_TYPE +# define __SYSCALL_ULONG_TYPE __UQUAD_TYPE +#else +# define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE +# define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE +#endif + +#define __DEV_T_TYPE __UQUAD_TYPE +#define __UID_T_TYPE __U32_TYPE +#define __GID_T_TYPE __U32_TYPE +#define __INO_T_TYPE __SYSCALL_ULONG_TYPE +#define __INO64_T_TYPE __UQUAD_TYPE +#define __MODE_T_TYPE __U32_TYPE +#ifdef __x86_64__ +# define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE +# define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE +#else +# define __NLINK_T_TYPE __UWORD_TYPE +# define __FSWORD_T_TYPE __SWORD_TYPE +#endif +#define __OFF_T_TYPE __SYSCALL_SLONG_TYPE +#define __OFF64_T_TYPE __SQUAD_TYPE +#define __PID_T_TYPE __S32_TYPE +#define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE +#define __RLIM64_T_TYPE __UQUAD_TYPE +#define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE +#define __BLKCNT64_T_TYPE __SQUAD_TYPE +#define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE +#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE +#define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE +#define __FSFILCNT64_T_TYPE __UQUAD_TYPE +#define __ID_T_TYPE __U32_TYPE +#define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE +#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE +#define __USECONDS_T_TYPE __U32_TYPE +#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE +#define __DADDR_T_TYPE __S32_TYPE +#define __KEY_T_TYPE __S32_TYPE +#define __CLOCKID_T_TYPE __S32_TYPE +#define __TIMER_T_TYPE void * +#define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE +#define __FSID_T_TYPE struct { int __val[2]; } +#define __SSIZE_T_TYPE __SWORD_TYPE + +#ifdef __x86_64__ +/* Tell the libc code that off_t and off64_t are actually the same type + for all ABI purposes, even if possibly expressed as different base types + for C type-checking purposes. */ +# define __OFF_T_MATCHES_OFF64_T 1 + +/* Same for ino_t and ino64_t. */ +# define __INO_T_MATCHES_INO64_T 1 +#endif + +/* Number of descriptors that can fit in an `fd_set'. */ +#define __FD_SETSIZE 1024 + + +#endif /* bits/typesizes.h */ diff --git a/libktorrent/miniboost/bits/unistd.h b/libktorrent/miniboost/bits/unistd.h new file mode 100644 index 00000000..41cf7280 --- /dev/null +++ b/libktorrent/miniboost/bits/unistd.h @@ -0,0 +1,385 @@ +/* Checking macros for unistd functions. + Copyright (C) 2005-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _UNISTD_H +# error "Never include directly; use instead." +#endif + +extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes, + size_t __buflen) __wur; +extern ssize_t __REDIRECT (__read_alias, (int __fd, void *__buf, + size_t __nbytes), read) __wur; +extern ssize_t __REDIRECT (__read_chk_warn, + (int __fd, void *__buf, size_t __nbytes, + size_t __buflen), __read_chk) + __wur __warnattr ("read called with bigger length than size of " + "the destination buffer"); + +__fortify_function __wur ssize_t +read (int __fd, void *__buf, size_t __nbytes) +{ + if (__bos0 (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__nbytes)) + return __read_chk (__fd, __buf, __nbytes, __bos0 (__buf)); + + if (__nbytes > __bos0 (__buf)) + return __read_chk_warn (__fd, __buf, __nbytes, __bos0 (__buf)); + } + return __read_alias (__fd, __buf, __nbytes); +} + +#ifdef __USE_UNIX98 +extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes, + __off_t __offset, size_t __bufsize) __wur; +extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes, + __off64_t __offset, size_t __bufsize) __wur; +extern ssize_t __REDIRECT (__pread_alias, + (int __fd, void *__buf, size_t __nbytes, + __off_t __offset), pread) __wur; +extern ssize_t __REDIRECT (__pread64_alias, + (int __fd, void *__buf, size_t __nbytes, + __off64_t __offset), pread64) __wur; +extern ssize_t __REDIRECT (__pread_chk_warn, + (int __fd, void *__buf, size_t __nbytes, + __off_t __offset, size_t __bufsize), __pread_chk) + __wur __warnattr ("pread called with bigger length than size of " + "the destination buffer"); +extern ssize_t __REDIRECT (__pread64_chk_warn, + (int __fd, void *__buf, size_t __nbytes, + __off64_t __offset, size_t __bufsize), + __pread64_chk) + __wur __warnattr ("pread64 called with bigger length than size of " + "the destination buffer"); + +# ifndef __USE_FILE_OFFSET64 +__fortify_function __wur ssize_t +pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset) +{ + if (__bos0 (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__nbytes)) + return __pread_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); + + if ( __nbytes > __bos0 (__buf)) + return __pread_chk_warn (__fd, __buf, __nbytes, __offset, + __bos0 (__buf)); + } + return __pread_alias (__fd, __buf, __nbytes, __offset); +} +# else +__fortify_function __wur ssize_t +pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) +{ + if (__bos0 (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__nbytes)) + return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); + + if ( __nbytes > __bos0 (__buf)) + return __pread64_chk_warn (__fd, __buf, __nbytes, __offset, + __bos0 (__buf)); + } + + return __pread64_alias (__fd, __buf, __nbytes, __offset); +} +# endif + +# ifdef __USE_LARGEFILE64 +__fortify_function __wur ssize_t +pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) +{ + if (__bos0 (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__nbytes)) + return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); + + if ( __nbytes > __bos0 (__buf)) + return __pread64_chk_warn (__fd, __buf, __nbytes, __offset, + __bos0 (__buf)); + } + + return __pread64_alias (__fd, __buf, __nbytes, __offset); +} +# endif +#endif + +#if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K +extern ssize_t __readlink_chk (const char *__restrict __path, + char *__restrict __buf, size_t __len, + size_t __buflen) + __THROW __nonnull ((1, 2)) __wur; +extern ssize_t __REDIRECT_NTH (__readlink_alias, + (const char *__restrict __path, + char *__restrict __buf, size_t __len), readlink) + __nonnull ((1, 2)) __wur; +extern ssize_t __REDIRECT_NTH (__readlink_chk_warn, + (const char *__restrict __path, + char *__restrict __buf, size_t __len, + size_t __buflen), __readlink_chk) + __nonnull ((1, 2)) __wur __warnattr ("readlink called with bigger length " + "than size of destination buffer"); + +__fortify_function __nonnull ((1, 2)) __wur ssize_t +__NTH (readlink (const char *__restrict __path, char *__restrict __buf, + size_t __len)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __readlink_chk (__path, __buf, __len, __bos (__buf)); + + if ( __len > __bos (__buf)) + return __readlink_chk_warn (__path, __buf, __len, __bos (__buf)); + } + return __readlink_alias (__path, __buf, __len); +} +#endif + +#ifdef __USE_ATFILE +extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path, + char *__restrict __buf, size_t __len, + size_t __buflen) + __THROW __nonnull ((2, 3)) __wur; +extern ssize_t __REDIRECT_NTH (__readlinkat_alias, + (int __fd, const char *__restrict __path, + char *__restrict __buf, size_t __len), + readlinkat) + __nonnull ((2, 3)) __wur; +extern ssize_t __REDIRECT_NTH (__readlinkat_chk_warn, + (int __fd, const char *__restrict __path, + char *__restrict __buf, size_t __len, + size_t __buflen), __readlinkat_chk) + __nonnull ((2, 3)) __wur __warnattr ("readlinkat called with bigger " + "length than size of destination " + "buffer"); + +__fortify_function __nonnull ((2, 3)) __wur ssize_t +__NTH (readlinkat (int __fd, const char *__restrict __path, + char *__restrict __buf, size_t __len)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __readlinkat_chk (__fd, __path, __buf, __len, __bos (__buf)); + + if (__len > __bos (__buf)) + return __readlinkat_chk_warn (__fd, __path, __buf, __len, + __bos (__buf)); + } + return __readlinkat_alias (__fd, __path, __buf, __len); +} +#endif + +extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen) + __THROW __wur; +extern char *__REDIRECT_NTH (__getcwd_alias, + (char *__buf, size_t __size), getcwd) __wur; +extern char *__REDIRECT_NTH (__getcwd_chk_warn, + (char *__buf, size_t __size, size_t __buflen), + __getcwd_chk) + __wur __warnattr ("getcwd caller with bigger length than size of " + "destination buffer"); + +__fortify_function __wur char * +__NTH (getcwd (char *__buf, size_t __size)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__size)) + return __getcwd_chk (__buf, __size, __bos (__buf)); + + if (__size > __bos (__buf)) + return __getcwd_chk_warn (__buf, __size, __bos (__buf)); + } + return __getcwd_alias (__buf, __size); +} + +#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED +extern char *__getwd_chk (char *__buf, size_t buflen) + __THROW __nonnull ((1)) __wur; +extern char *__REDIRECT_NTH (__getwd_warn, (char *__buf), getwd) + __nonnull ((1)) __wur __warnattr ("please use getcwd instead, as getwd " + "doesn't specify buffer size"); + +__fortify_function __nonnull ((1)) __attribute_deprecated__ __wur char * +__NTH (getwd (char *__buf)) +{ + if (__bos (__buf) != (size_t) -1) + return __getwd_chk (__buf, __bos (__buf)); + return __getwd_warn (__buf); +} +#endif + +extern size_t __confstr_chk (int __name, char *__buf, size_t __len, + size_t __buflen) __THROW; +extern size_t __REDIRECT_NTH (__confstr_alias, (int __name, char *__buf, + size_t __len), confstr); +extern size_t __REDIRECT_NTH (__confstr_chk_warn, + (int __name, char *__buf, size_t __len, + size_t __buflen), __confstr_chk) + __warnattr ("confstr called with bigger length than size of destination " + "buffer"); + +__fortify_function size_t +__NTH (confstr (int __name, char *__buf, size_t __len)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __confstr_chk (__name, __buf, __len, __bos (__buf)); + + if (__bos (__buf) < __len) + return __confstr_chk_warn (__name, __buf, __len, __bos (__buf)); + } + return __confstr_alias (__name, __buf, __len); +} + + +extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen) + __THROW __wur; +extern int __REDIRECT_NTH (__getgroups_alias, (int __size, __gid_t __list[]), + getgroups) __wur; +extern int __REDIRECT_NTH (__getgroups_chk_warn, + (int __size, __gid_t __list[], size_t __listlen), + __getgroups_chk) + __wur __warnattr ("getgroups called with bigger group count than what " + "can fit into destination buffer"); + +__fortify_function int +__NTH (getgroups (int __size, __gid_t __list[])) +{ + if (__bos (__list) != (size_t) -1) + { + if (!__builtin_constant_p (__size) || __size < 0) + return __getgroups_chk (__size, __list, __bos (__list)); + + if (__size * sizeof (__gid_t) > __bos (__list)) + return __getgroups_chk_warn (__size, __list, __bos (__list)); + } + return __getgroups_alias (__size, __list); +} + + +extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen, + size_t __nreal) __THROW __nonnull ((2)); +extern int __REDIRECT_NTH (__ttyname_r_alias, (int __fd, char *__buf, + size_t __buflen), ttyname_r) + __nonnull ((2)); +extern int __REDIRECT_NTH (__ttyname_r_chk_warn, + (int __fd, char *__buf, size_t __buflen, + size_t __nreal), __ttyname_r_chk) + __nonnull ((2)) __warnattr ("ttyname_r called with bigger buflen than " + "size of destination buffer"); + +__fortify_function int +__NTH (ttyname_r (int __fd, char *__buf, size_t __buflen)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__buflen)) + return __ttyname_r_chk (__fd, __buf, __buflen, __bos (__buf)); + + if (__buflen > __bos (__buf)) + return __ttyname_r_chk_warn (__fd, __buf, __buflen, __bos (__buf)); + } + return __ttyname_r_alias (__fd, __buf, __buflen); +} + + +#if defined __USE_REENTRANT || defined __USE_POSIX199506 +extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal) + __nonnull ((1)); +extern int __REDIRECT (__getlogin_r_alias, (char *__buf, size_t __buflen), + getlogin_r) __nonnull ((1)); +extern int __REDIRECT (__getlogin_r_chk_warn, + (char *__buf, size_t __buflen, size_t __nreal), + __getlogin_r_chk) + __nonnull ((1)) __warnattr ("getlogin_r called with bigger buflen than " + "size of destination buffer"); + +__fortify_function int +getlogin_r (char *__buf, size_t __buflen) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__buflen)) + return __getlogin_r_chk (__buf, __buflen, __bos (__buf)); + + if (__buflen > __bos (__buf)) + return __getlogin_r_chk_warn (__buf, __buflen, __bos (__buf)); + } + return __getlogin_r_alias (__buf, __buflen); +} +#endif + + +#if defined __USE_MISC || defined __USE_UNIX98 +extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal) + __THROW __nonnull ((1)); +extern int __REDIRECT_NTH (__gethostname_alias, (char *__buf, size_t __buflen), + gethostname) __nonnull ((1)); +extern int __REDIRECT_NTH (__gethostname_chk_warn, + (char *__buf, size_t __buflen, size_t __nreal), + __gethostname_chk) + __nonnull ((1)) __warnattr ("gethostname called with bigger buflen than " + "size of destination buffer"); + +__fortify_function int +__NTH (gethostname (char *__buf, size_t __buflen)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__buflen)) + return __gethostname_chk (__buf, __buflen, __bos (__buf)); + + if (__buflen > __bos (__buf)) + return __gethostname_chk_warn (__buf, __buflen, __bos (__buf)); + } + return __gethostname_alias (__buf, __buflen); +} +#endif + + +#if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_UNIX98) +extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal) + __THROW __nonnull ((1)) __wur; +extern int __REDIRECT_NTH (__getdomainname_alias, (char *__buf, + size_t __buflen), + getdomainname) __nonnull ((1)) __wur; +extern int __REDIRECT_NTH (__getdomainname_chk_warn, + (char *__buf, size_t __buflen, size_t __nreal), + __getdomainname_chk) + __nonnull ((1)) __wur __warnattr ("getdomainname called with bigger " + "buflen than size of destination " + "buffer"); + +__fortify_function int +__NTH (getdomainname (char *__buf, size_t __buflen)) +{ + if (__bos (__buf) != (size_t) -1) + { + if (!__builtin_constant_p (__buflen)) + return __getdomainname_chk (__buf, __buflen, __bos (__buf)); + + if (__buflen > __bos (__buf)) + return __getdomainname_chk_warn (__buf, __buflen, __bos (__buf)); + } + return __getdomainname_alias (__buf, __buflen); +} +#endif diff --git a/libktorrent/miniboost/bits/waitflags.h b/libktorrent/miniboost/bits/waitflags.h new file mode 100644 index 00000000..0f4e7b44 --- /dev/null +++ b/libktorrent/miniboost/bits/waitflags.h @@ -0,0 +1,37 @@ +/* Definitions of flag bits for `waitpid' et al. + Copyright (C) 1992-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#if !defined _SYS_WAIT_H && !defined _STDLIB_H +# error "Never include directly; use instead." +#endif + + +/* Bits in the third argument to `waitpid'. */ +#define WNOHANG 1 /* Don't block waiting. */ +#define WUNTRACED 2 /* Report status of stopped children. */ + +/* Bits in the fourth argument to `waitid'. */ +#define WSTOPPED 2 /* Report stopped child (same as WUNTRACED). */ +#define WEXITED 4 /* Report dead child. */ +#define WCONTINUED 8 /* Report continued child. */ +#define WNOWAIT 0x01000000 /* Don't reap, just poll status. */ + +#define __WNOTHREAD 0x20000000 /* Don't wait on children of other threads + in this group */ +#define __WALL 0x40000000 /* Wait for any child. */ +#define __WCLONE 0x80000000 /* Wait for cloned process. */ diff --git a/libktorrent/miniboost/bits/waitstatus.h b/libktorrent/miniboost/bits/waitstatus.h new file mode 100644 index 00000000..50875748 --- /dev/null +++ b/libktorrent/miniboost/bits/waitstatus.h @@ -0,0 +1,105 @@ +/* Definitions of status bits for `wait' et al. + Copyright (C) 1992-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#if !defined _SYS_WAIT_H && !defined _STDLIB_H +# error "Never include directly; use instead." +#endif + + +/* Everything extant so far uses these same bits. */ + + +/* If WIFEXITED(STATUS), the low-order 8 bits of the status. */ +#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8) + +/* If WIFSIGNALED(STATUS), the terminating signal. */ +#define __WTERMSIG(status) ((status) & 0x7f) + +/* If WIFSTOPPED(STATUS), the signal that stopped the child. */ +#define __WSTOPSIG(status) __WEXITSTATUS(status) + +/* Nonzero if STATUS indicates normal termination. */ +#define __WIFEXITED(status) (__WTERMSIG(status) == 0) + +/* Nonzero if STATUS indicates termination by a signal. */ +#define __WIFSIGNALED(status) \ + (((signed char) (((status) & 0x7f) + 1) >> 1) > 0) + +/* Nonzero if STATUS indicates the child is stopped. */ +#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f) + +/* Nonzero if STATUS indicates the child continued after a stop. We only + define this if provides the WCONTINUED flag bit. */ +#ifdef WCONTINUED +# define __WIFCONTINUED(status) ((status) == __W_CONTINUED) +#endif + +/* Nonzero if STATUS indicates the child dumped core. */ +#define __WCOREDUMP(status) ((status) & __WCOREFLAG) + +/* Macros for constructing status values. */ +#define __W_EXITCODE(ret, sig) ((ret) << 8 | (sig)) +#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f) +#define __W_CONTINUED 0xffff +#define __WCOREFLAG 0x80 + + +#ifdef __USE_MISC + +# include + +union wait + { + int w_status; + struct + { +# if __BYTE_ORDER == __LITTLE_ENDIAN + unsigned int __w_termsig:7; /* Terminating signal. */ + unsigned int __w_coredump:1; /* Set if dumped core. */ + unsigned int __w_retcode:8; /* Return code if exited normally. */ + unsigned int:16; +# endif /* Little endian. */ +# if __BYTE_ORDER == __BIG_ENDIAN + unsigned int:16; + unsigned int __w_retcode:8; + unsigned int __w_coredump:1; + unsigned int __w_termsig:7; +# endif /* Big endian. */ + } __wait_terminated; + struct + { +# if __BYTE_ORDER == __LITTLE_ENDIAN + unsigned int __w_stopval:8; /* W_STOPPED if stopped. */ + unsigned int __w_stopsig:8; /* Stopping signal. */ + unsigned int:16; +# endif /* Little endian. */ +# if __BYTE_ORDER == __BIG_ENDIAN + unsigned int:16; + unsigned int __w_stopsig:8; /* Stopping signal. */ + unsigned int __w_stopval:8; /* W_STOPPED if stopped. */ +# endif /* Big endian. */ + } __wait_stopped; + }; + +# define w_termsig __wait_terminated.__w_termsig +# define w_coredump __wait_terminated.__w_coredump +# define w_retcode __wait_terminated.__w_retcode +# define w_stopsig __wait_stopped.__w_stopsig +# define w_stopval __wait_stopped.__w_stopval + +#endif /* Use misc. */ diff --git a/libktorrent/miniboost/bits/wchar-ldbl.h b/libktorrent/miniboost/bits/wchar-ldbl.h new file mode 100644 index 00000000..45453be1 --- /dev/null +++ b/libktorrent/miniboost/bits/wchar-ldbl.h @@ -0,0 +1,74 @@ +/* -mlong-double-64 compatibility mode for functions. + Copyright (C) 2006-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _WCHAR_H +# error "Never include directly; use instead." +#endif + +#if defined __USE_ISOC95 || defined __USE_UNIX98 +__BEGIN_NAMESPACE_C99 +__LDBL_REDIR_DECL (fwprintf); +__LDBL_REDIR_DECL (wprintf); +__LDBL_REDIR_DECL (swprintf); +__LDBL_REDIR_DECL (vfwprintf); +__LDBL_REDIR_DECL (vwprintf); +__LDBL_REDIR_DECL (vswprintf); +# if defined __USE_ISOC99 && !defined __USE_GNU \ + && !defined __REDIRECT \ + && (defined __STRICT_ANSI__ || defined __USE_XOPEN2K) +__LDBL_REDIR1_DECL (fwscanf, __nldbl___isoc99_fwscanf) +__LDBL_REDIR1_DECL (wscanf, __nldbl___isoc99_wscanf) +__LDBL_REDIR1_DECL (swscanf, __nldbl___isoc99_swscanf) +# else +__LDBL_REDIR_DECL (fwscanf); +__LDBL_REDIR_DECL (wscanf); +__LDBL_REDIR_DECL (swscanf); +# endif +__END_NAMESPACE_C99 +#endif + +#ifdef __USE_ISOC99 +__BEGIN_NAMESPACE_C99 +__LDBL_REDIR1_DECL (wcstold, wcstod); +# if !defined __USE_GNU && !defined __REDIRECT \ + && (defined __STRICT_ANSI__ || defined __USE_XOPEN2K) +__LDBL_REDIR1_DECL (vfwscanf, __nldbl___isoc99_vfwscanf) +__LDBL_REDIR1_DECL (vwscanf, __nldbl___isoc99_vwscanf) +__LDBL_REDIR1_DECL (vswscanf, __nldbl___isoc99_vswscanf) +# else +__LDBL_REDIR_DECL (vfwscanf); +__LDBL_REDIR_DECL (vwscanf); +__LDBL_REDIR_DECL (vswscanf); +# endif +__END_NAMESPACE_C99 +#endif + +#ifdef __USE_GNU +__LDBL_REDIR1_DECL (wcstold_l, wcstod_l); +#endif + +#if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function +__LDBL_REDIR_DECL (__swprintf_chk) +__LDBL_REDIR_DECL (__vswprintf_chk) +# if __USE_FORTIFY_LEVEL > 1 +__LDBL_REDIR_DECL (__fwprintf_chk) +__LDBL_REDIR_DECL (__wprintf_chk) +__LDBL_REDIR_DECL (__vfwprintf_chk) +__LDBL_REDIR_DECL (__vwprintf_chk) +# endif +#endif diff --git a/libktorrent/miniboost/bits/wchar.h b/libktorrent/miniboost/bits/wchar.h new file mode 100644 index 00000000..e4ca8dbf --- /dev/null +++ b/libktorrent/miniboost/bits/wchar.h @@ -0,0 +1,49 @@ +/* wchar_t type related definitions. + Copyright (C) 2000-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_WCHAR_H +#define _BITS_WCHAR_H 1 + +/* The fallback definitions, for when __WCHAR_MAX__ or __WCHAR_MIN__ + are not defined, give the right value and type as long as both int + and wchar_t are 32-bit types. Adding L'\0' to a constant value + ensures that the type is correct; it is necessary to use (L'\0' + + 0) rather than just L'\0' so that the type in C++ is the promoted + version of wchar_t rather than the distinct wchar_t type itself. + Because wchar_t in preprocessor #if expressions is treated as + intmax_t or uintmax_t, the expression (L'\0' - 1) would have the + wrong value for WCHAR_MAX in such expressions and so cannot be used + to define __WCHAR_MAX in the unsigned case. */ + +#ifdef __WCHAR_MAX__ +# define __WCHAR_MAX __WCHAR_MAX__ +#elif L'\0' - 1 > 0 +# define __WCHAR_MAX (0xffffffffu + L'\0') +#else +# define __WCHAR_MAX (0x7fffffff + L'\0') +#endif + +#ifdef __WCHAR_MIN__ +# define __WCHAR_MIN __WCHAR_MIN__ +#elif L'\0' - 1 > 0 +# define __WCHAR_MIN (L'\0' + 0) +#else +# define __WCHAR_MIN (-__WCHAR_MAX - 1) +#endif + +#endif /* bits/wchar.h */ diff --git a/libktorrent/miniboost/bits/wchar2.h b/libktorrent/miniboost/bits/wchar2.h new file mode 100644 index 00000000..29ac6b31 --- /dev/null +++ b/libktorrent/miniboost/bits/wchar2.h @@ -0,0 +1,593 @@ +/* Checking macros for wchar functions. + Copyright (C) 2005-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _WCHAR_H +# error "Never include directly; use instead." +#endif + + +extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n, + size_t __ns1) __THROW; +extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias, + (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n), + wmemcpy); +extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn, + (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n, + size_t __ns1), __wmemcpy_chk) + __warnattr ("wmemcpy called with length bigger than size of destination " + "buffer"); + +__fortify_function wchar_t * +__NTH (wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, + size_t __n)) +{ + if (__bos0 (__s1) != (size_t) -1) + { + if (!__builtin_constant_p (__n)) + return __wmemcpy_chk (__s1, __s2, __n, + __bos0 (__s1) / sizeof (wchar_t)); + + if (__n > __bos0 (__s1) / sizeof (wchar_t)) + return __wmemcpy_chk_warn (__s1, __s2, __n, + __bos0 (__s1) / sizeof (wchar_t)); + } + return __wmemcpy_alias (__s1, __s2, __n); +} + + +extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2, + size_t __n, size_t __ns1) __THROW; +extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1, + const wchar_t *__s2, + size_t __n), wmemmove); +extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn, + (wchar_t *__s1, const wchar_t *__s2, + size_t __n, size_t __ns1), __wmemmove_chk) + __warnattr ("wmemmove called with length bigger than size of destination " + "buffer"); + +__fortify_function wchar_t * +__NTH (wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)) +{ + if (__bos0 (__s1) != (size_t) -1) + { + if (!__builtin_constant_p (__n)) + return __wmemmove_chk (__s1, __s2, __n, + __bos0 (__s1) / sizeof (wchar_t)); + + if (__n > __bos0 (__s1) / sizeof (wchar_t)) + return __wmemmove_chk_warn (__s1, __s2, __n, + __bos0 (__s1) / sizeof (wchar_t)); + } + return __wmemmove_alias (__s1, __s2, __n); +} + + +#ifdef __USE_GNU +extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n, + size_t __ns1) __THROW; +extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias, + (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, + size_t __n), wmempcpy); +extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn, + (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n, + size_t __ns1), __wmempcpy_chk) + __warnattr ("wmempcpy called with length bigger than size of destination " + "buffer"); + +__fortify_function wchar_t * +__NTH (wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, + size_t __n)) +{ + if (__bos0 (__s1) != (size_t) -1) + { + if (!__builtin_constant_p (__n)) + return __wmempcpy_chk (__s1, __s2, __n, + __bos0 (__s1) / sizeof (wchar_t)); + + if (__n > __bos0 (__s1) / sizeof (wchar_t)) + return __wmempcpy_chk_warn (__s1, __s2, __n, + __bos0 (__s1) / sizeof (wchar_t)); + } + return __wmempcpy_alias (__s1, __s2, __n); +} +#endif + + +extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n, + size_t __ns) __THROW; +extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c, + size_t __n), wmemset); +extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn, + (wchar_t *__s, wchar_t __c, size_t __n, + size_t __ns), __wmemset_chk) + __warnattr ("wmemset called with length bigger than size of destination " + "buffer"); + +__fortify_function wchar_t * +__NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n)) +{ + if (__bos0 (__s) != (size_t) -1) + { + if (!__builtin_constant_p (__n)) + return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t)); + + if (__n > __bos0 (__s) / sizeof (wchar_t)) + return __wmemset_chk_warn (__s, __c, __n, + __bos0 (__s) / sizeof (wchar_t)); + } + return __wmemset_alias (__s, __c, __n); +} + + +extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n) __THROW; +extern wchar_t *__REDIRECT_NTH (__wcscpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src), wcscpy); + +__fortify_function wchar_t * +__NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) +{ + if (__bos (__dest) != (size_t) -1) + return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); + return __wcscpy_alias (__dest, __src); +} + + +extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __destlen) __THROW; +extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src), wcpcpy); + +__fortify_function wchar_t * +__NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) +{ + if (__bos (__dest) != (size_t) -1) + return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); + return __wcpcpy_alias (__dest, __src); +} + + +extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n, + size_t __destlen) __THROW; +extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n), wcsncpy); +extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n, size_t __destlen), __wcsncpy_chk) + __warnattr ("wcsncpy called with length bigger than size of destination " + "buffer"); + +__fortify_function wchar_t * +__NTH (wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, + size_t __n)) +{ + if (__bos (__dest) != (size_t) -1) + { + if (!__builtin_constant_p (__n)) + return __wcsncpy_chk (__dest, __src, __n, + __bos (__dest) / sizeof (wchar_t)); + if (__n > __bos (__dest) / sizeof (wchar_t)) + return __wcsncpy_chk_warn (__dest, __src, __n, + __bos (__dest) / sizeof (wchar_t)); + } + return __wcsncpy_alias (__dest, __src, __n); +} + + +extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n, + size_t __destlen) __THROW; +extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n), wcpncpy); +extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n, size_t __destlen), __wcpncpy_chk) + __warnattr ("wcpncpy called with length bigger than size of destination " + "buffer"); + +__fortify_function wchar_t * +__NTH (wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, + size_t __n)) +{ + if (__bos (__dest) != (size_t) -1) + { + if (!__builtin_constant_p (__n)) + return __wcpncpy_chk (__dest, __src, __n, + __bos (__dest) / sizeof (wchar_t)); + if (__n > __bos (__dest) / sizeof (wchar_t)) + return __wcpncpy_chk_warn (__dest, __src, __n, + __bos (__dest) / sizeof (wchar_t)); + } + return __wcpncpy_alias (__dest, __src, __n); +} + + +extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __destlen) __THROW; +extern wchar_t *__REDIRECT_NTH (__wcscat_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src), wcscat); + +__fortify_function wchar_t * +__NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) +{ + if (__bos (__dest) != (size_t) -1) + return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); + return __wcscat_alias (__dest, __src); +} + + +extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n, size_t __destlen) __THROW; +extern wchar_t *__REDIRECT_NTH (__wcsncat_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n), wcsncat); + +__fortify_function wchar_t * +__NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, + size_t __n)) +{ + if (__bos (__dest) != (size_t) -1) + return __wcsncat_chk (__dest, __src, __n, + __bos (__dest) / sizeof (wchar_t)); + return __wcsncat_alias (__dest, __src, __n); +} + + +extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n, + int __flag, size_t __s_len, + const wchar_t *__restrict __format, ...) + __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */; + +extern int __REDIRECT_NTH_LDBL (__swprintf_alias, + (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __fmt, ...), + swprintf); + +#ifdef __va_arg_pack +__fortify_function int +__NTH (swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __fmt, ...)) +{ + if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) + return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, + __bos (__s) / sizeof (wchar_t), + __fmt, __va_arg_pack ()); + return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ()); +} +#elif !defined __cplusplus +/* XXX We might want to have support in gcc for swprintf. */ +# define swprintf(s, n, ...) \ + (__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1 \ + ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, \ + __bos (s) / sizeof (wchar_t), __VA_ARGS__) \ + : swprintf (s, n, __VA_ARGS__)) +#endif + +extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, + int __flag, size_t __s_len, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */; + +extern int __REDIRECT_NTH_LDBL (__vswprintf_alias, + (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __fmt, + __gnuc_va_list __ap), vswprintf); + +__fortify_function int +__NTH (vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __fmt, __gnuc_va_list __ap)) +{ + if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) + return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, + __bos (__s) / sizeof (wchar_t), __fmt, __ap); + return __vswprintf_alias (__s, __n, __fmt, __ap); +} + + +#if __USE_FORTIFY_LEVEL > 1 + +extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag, + const wchar_t *__restrict __format, ...); +extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format, + ...); +extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag, + const wchar_t *__restrict __format, + __gnuc_va_list __ap); +extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format, + __gnuc_va_list __ap); + +# ifdef __va_arg_pack +__fortify_function int +wprintf (const wchar_t *__restrict __fmt, ...) +{ + return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); +} + +__fortify_function int +fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...) +{ + return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, + __va_arg_pack ()); +} +# elif !defined __cplusplus +# define wprintf(...) \ + __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# define fwprintf(stream, ...) \ + __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) +# endif + +__fortify_function int +vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap) +{ + return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); +} + +__fortify_function int +vfwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __fmt, __gnuc_va_list __ap) +{ + return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +} + +#endif + +extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n, + __FILE *__restrict __stream) __wur; +extern wchar_t *__REDIRECT (__fgetws_alias, + (wchar_t *__restrict __s, int __n, + __FILE *__restrict __stream), fgetws) __wur; +extern wchar_t *__REDIRECT (__fgetws_chk_warn, + (wchar_t *__restrict __s, size_t __size, int __n, + __FILE *__restrict __stream), __fgetws_chk) + __wur __warnattr ("fgetws called with bigger size than length " + "of destination buffer"); + +__fortify_function __wur wchar_t * +fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) +{ + if (__bos (__s) != (size_t) -1) + { + if (!__builtin_constant_p (__n) || __n <= 0) + return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t), + __n, __stream); + + if ((size_t) __n > __bos (__s) / sizeof (wchar_t)) + return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t), + __n, __stream); + } + return __fgetws_alias (__s, __n, __stream); +} + +#ifdef __USE_GNU +extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size, + int __n, __FILE *__restrict __stream) + __wur; +extern wchar_t *__REDIRECT (__fgetws_unlocked_alias, + (wchar_t *__restrict __s, int __n, + __FILE *__restrict __stream), fgetws_unlocked) + __wur; +extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn, + (wchar_t *__restrict __s, size_t __size, int __n, + __FILE *__restrict __stream), + __fgetws_unlocked_chk) + __wur __warnattr ("fgetws_unlocked called with bigger size than length " + "of destination buffer"); + +__fortify_function __wur wchar_t * +fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) +{ + if (__bos (__s) != (size_t) -1) + { + if (!__builtin_constant_p (__n) || __n <= 0) + return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t), + __n, __stream); + + if ((size_t) __n > __bos (__s) / sizeof (wchar_t)) + return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t), + __n, __stream); + } + return __fgetws_unlocked_alias (__s, __n, __stream); +} +#endif + + +extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar, + mbstate_t *__restrict __p, + size_t __buflen) __THROW __wur; +extern size_t __REDIRECT_NTH (__wcrtomb_alias, + (char *__restrict __s, wchar_t __wchar, + mbstate_t *__restrict __ps), wcrtomb) __wur; + +__fortify_function __wur size_t +__NTH (wcrtomb (char *__restrict __s, wchar_t __wchar, + mbstate_t *__restrict __ps)) +{ + /* We would have to include to get a definition of MB_LEN_MAX. + But this would only disturb the namespace. So we define our own + version here. */ +#define __WCHAR_MB_LEN_MAX 16 +#if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX +# error "Assumed value of MB_LEN_MAX wrong" +#endif + if (__bos (__s) != (size_t) -1 && __WCHAR_MB_LEN_MAX > __bos (__s)) + return __wcrtomb_chk (__s, __wchar, __ps, __bos (__s)); + return __wcrtomb_alias (__s, __wchar, __ps); +} + + +extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst, + const char **__restrict __src, + size_t __len, mbstate_t *__restrict __ps, + size_t __dstlen) __THROW; +extern size_t __REDIRECT_NTH (__mbsrtowcs_alias, + (wchar_t *__restrict __dst, + const char **__restrict __src, + size_t __len, mbstate_t *__restrict __ps), + mbsrtowcs); +extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn, + (wchar_t *__restrict __dst, + const char **__restrict __src, + size_t __len, mbstate_t *__restrict __ps, + size_t __dstlen), __mbsrtowcs_chk) + __warnattr ("mbsrtowcs called with dst buffer smaller than len " + "* sizeof (wchar_t)"); + +__fortify_function size_t +__NTH (mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, + size_t __len, mbstate_t *__restrict __ps)) +{ + if (__bos (__dst) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __mbsrtowcs_chk (__dst, __src, __len, __ps, + __bos (__dst) / sizeof (wchar_t)); + + if (__len > __bos (__dst) / sizeof (wchar_t)) + return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps, + __bos (__dst) / sizeof (wchar_t)); + } + return __mbsrtowcs_alias (__dst, __src, __len, __ps); +} + + +extern size_t __wcsrtombs_chk (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __len, mbstate_t *__restrict __ps, + size_t __dstlen) __THROW; +extern size_t __REDIRECT_NTH (__wcsrtombs_alias, + (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __len, mbstate_t *__restrict __ps), + wcsrtombs); +extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn, + (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __len, mbstate_t *__restrict __ps, + size_t __dstlen), __wcsrtombs_chk) + __warnattr ("wcsrtombs called with dst buffer smaller than len"); + +__fortify_function size_t +__NTH (wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, + size_t __len, mbstate_t *__restrict __ps)) +{ + if (__bos (__dst) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst)); + + if (__len > __bos (__dst)) + return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst)); + } + return __wcsrtombs_alias (__dst, __src, __len, __ps); +} + + +#ifdef __USE_GNU +extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps, + size_t __dstlen) __THROW; +extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias, + (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps), + mbsnrtowcs); +extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn, + (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps, + size_t __dstlen), __mbsnrtowcs_chk) + __warnattr ("mbsnrtowcs called with dst buffer smaller than len " + "* sizeof (wchar_t)"); + +__fortify_function size_t +__NTH (mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, + size_t __nmc, size_t __len, mbstate_t *__restrict __ps)) +{ + if (__bos (__dst) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, + __bos (__dst) / sizeof (wchar_t)); + + if (__len > __bos (__dst) / sizeof (wchar_t)) + return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps, + __bos (__dst) / sizeof (wchar_t)); + } + return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps); +} + + +extern size_t __wcsnrtombs_chk (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps, size_t __dstlen) + __THROW; +extern size_t __REDIRECT_NTH (__wcsnrtombs_alias, + (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps), wcsnrtombs); +extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn, + (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps, + size_t __dstlen), __wcsnrtombs_chk) + __warnattr ("wcsnrtombs called with dst buffer smaller than len"); + +__fortify_function size_t +__NTH (wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, + size_t __nwc, size_t __len, mbstate_t *__restrict __ps)) +{ + if (__bos (__dst) != (size_t) -1) + { + if (!__builtin_constant_p (__len)) + return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, + __bos (__dst)); + + if (__len > __bos (__dst)) + return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps, + __bos (__dst)); + } + return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps); +} +#endif diff --git a/libktorrent/miniboost/bits/wordsize.h b/libktorrent/miniboost/bits/wordsize.h new file mode 100644 index 00000000..e25af287 --- /dev/null +++ b/libktorrent/miniboost/bits/wordsize.h @@ -0,0 +1,13 @@ +/* Determine the wordsize from the preprocessor defines. */ + +#if defined __x86_64__ && !defined __ILP32__ +# define __WORDSIZE 64 +#else +# define __WORDSIZE 32 +#endif + +#ifdef __x86_64__ +# define __WORDSIZE_TIME64_COMPAT32 1 +/* Both x86-64 and x32 use the 64-bit system call interface. */ +# define __SYSCALL_WORDSIZE 64 +#endif diff --git a/libktorrent/miniboost/bits/xopen_lim.h b/libktorrent/miniboost/bits/xopen_lim.h new file mode 100644 index 00000000..63fd1d8b --- /dev/null +++ b/libktorrent/miniboost/bits/xopen_lim.h @@ -0,0 +1,143 @@ +/* Copyright (C) 1996-2014 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* + * Never include this file directly; use instead. + */ + +/* Additional definitions from X/Open Portability Guide, Issue 4, Version 2 + System Interfaces and Headers, 4.16 + + Please note only the values which are not greater than the minimum + stated in the standard document are listed. The `sysconf' functions + should be used to obtain the actual value. */ + +#ifndef _XOPEN_LIM_H +#define _XOPEN_LIM_H 1 + +#define __need_IOV_MAX +#include + +/* We do not provide fixed values for + + ARG_MAX Maximum length of argument to the `exec' function + including environment data. + + ATEXIT_MAX Maximum number of functions that may be registered + with `atexit'. + + CHILD_MAX Maximum number of simultaneous processes per real + user ID. + + OPEN_MAX Maximum number of files that one process can have open + at anyone time. + + PAGESIZE + PAGE_SIZE Size of bytes of a page. + + PASS_MAX Maximum number of significant bytes in a password. + + We only provide a fixed limit for + + IOV_MAX Maximum number of `iovec' structures that one process has + available for use with `readv' or writev'. + + if this is indeed fixed by the underlying system. +*/ + + +/* Maximum number of `iovec' structures that one process has available + for use with `readv' or writev'. */ +#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV + + +/* Maximum value of `digit' in calls to the `printf' and `scanf' + functions. We have no limit, so return a reasonable value. */ +#define NL_ARGMAX _POSIX_ARG_MAX + +/* Maximum number of bytes in a `LANG' name. We have no limit. */ +#define NL_LANGMAX _POSIX2_LINE_MAX + +/* Maximum message number. We have no limit. */ +#define NL_MSGMAX INT_MAX + +/* Maximum number of bytes in N-to-1 collation mapping. We have no + limit. */ +#define NL_NMAX INT_MAX + +/* Maximum set number. We have no limit. */ +#define NL_SETMAX INT_MAX + +/* Maximum number of bytes in a message. We have no limit. */ +#define NL_TEXTMAX INT_MAX + +/* Default process priority. */ +#define NZERO 20 + + +/* Number of bits in a word of type `int'. */ +#ifdef INT_MAX +# if INT_MAX == 32767 +# define WORD_BIT 16 +# else +# if INT_MAX == 2147483647 +# define WORD_BIT 32 +# else +/* Safe assumption. */ +# define WORD_BIT 64 +# endif +# endif +#elif defined __INT_MAX__ +# if __INT_MAX__ == 32767 +# define WORD_BIT 16 +# else +# if __INT_MAX__ == 2147483647 +# define WORD_BIT 32 +# else +/* Safe assumption. */ +# define WORD_BIT 64 +# endif +# endif +#else +# define WORD_BIT 32 +#endif + +/* Number of bits in a word of type `long int'. */ +#ifdef LONG_MAX +# if LONG_MAX == 2147483647 +# define LONG_BIT 32 +# else +/* Safe assumption. */ +# define LONG_BIT 64 +# endif +#elif defined __LONG_MAX__ +# if __LONG_MAX__ == 2147483647 +# define LONG_BIT 32 +# else +/* Safe assumption. */ +# define LONG_BIT 64 +# endif +#else +# include +# if __WORDSIZE == 64 +# define LONG_BIT 64 +# else +# define LONG_BIT 32 +# endif +#endif + +#endif /* bits/xopen_lim.h */ diff --git a/libktorrent/miniboost/boost/assert.hpp b/libktorrent/miniboost/boost/assert.hpp new file mode 100644 index 00000000..1713d9bb --- /dev/null +++ b/libktorrent/miniboost/boost/assert.hpp @@ -0,0 +1,78 @@ +// +// boost/assert.hpp - BOOST_ASSERT(expr) +// BOOST_ASSERT_MSG(expr, msg) +// BOOST_VERIFY(expr) +// BOOST_VERIFY_MSG(expr, msg) +// +// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. +// Copyright (c) 2007, 2014 Peter Dimov +// Copyright (c) Beman Dawes 2011 +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// Note: There are no include guards. This is intentional. +// +// See http://www.boost.org/libs/assert/assert.html for documentation. +// + +// +// Stop inspect complaining about use of 'assert': +// +// boostinspect:naassert_macro +// + +// +// BOOST_ASSERT, BOOST_ASSERT_MSG +// + +#undef BOOST_ASSERT +#undef BOOST_ASSERT_MSG + +#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) ) + +# define BOOST_ASSERT(expr) ((void)0) +# define BOOST_ASSERT_MSG(expr, msg) ((void)0) + +#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) ) + +#include // for BOOST_LIKELY +#include + +namespace boost +{ + void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined + void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined +} // namespace boost + +#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) +#define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) + +#else + +# include // .h to support old libraries w/o - effect is the same + +# define BOOST_ASSERT(expr) assert(expr) +# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) + +#endif + +// +// BOOST_VERIFY, BOOST_VERIFY_MSG +// + +#undef BOOST_VERIFY +#undef BOOST_VERIFY_MSG + +#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) ) + +# define BOOST_VERIFY(expr) ((void)(expr)) +# define BOOST_VERIFY_MSG(expr, msg) ((void)(expr)) + +#else + +# define BOOST_VERIFY(expr) BOOST_ASSERT(expr) +# define BOOST_VERIFY_MSG(expr, msg) BOOST_ASSERT_MSG(expr,msg) + +#endif diff --git a/libktorrent/miniboost/boost/call_traits.hpp b/libktorrent/miniboost/boost/call_traits.hpp new file mode 100644 index 00000000..2c1328e9 --- /dev/null +++ b/libktorrent/miniboost/boost/call_traits.hpp @@ -0,0 +1,20 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt). +// +// See http://www.boost.org/libs/utility for most recent version including documentation. + +// See boost/detail/call_traits.hpp +// for full copyright notices. + +#ifndef BOOST_CALL_TRAITS_HPP +#define BOOST_CALL_TRAITS_HPP + +#ifndef BOOST_CONFIG_HPP +#include +#endif + +#include + +#endif // BOOST_CALL_TRAITS_HPP diff --git a/libktorrent/miniboost/boost/checked_delete.hpp b/libktorrent/miniboost/boost/checked_delete.hpp new file mode 100644 index 00000000..fb71c789 --- /dev/null +++ b/libktorrent/miniboost/boost/checked_delete.hpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2014 Glen Fernandes + * + * Distributed under the Boost Software License, Version 1.0. (See + * accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef BOOST_CHECKED_DELETE_HPP +#define BOOST_CHECKED_DELETE_HPP + +// The header file at this path is deprecated; +// use boost/core/checked_delete.hpp instead. + +#include + +#endif diff --git a/libktorrent/miniboost/boost/circular_buffer.hpp b/libktorrent/miniboost/boost/circular_buffer.hpp new file mode 100644 index 00000000..f5eff60f --- /dev/null +++ b/libktorrent/miniboost/boost/circular_buffer.hpp @@ -0,0 +1,65 @@ +// Circular buffer library header file. + +// Copyright (c) 2003-2008 Jan Gaspar + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See www.boost.org/libs/circular_buffer for documentation. + +#if !defined(BOOST_CIRCULAR_BUFFER_HPP) +#define BOOST_CIRCULAR_BUFFER_HPP + +#if defined(_MSC_VER) + #pragma once +#endif + +#include +#include +#include + +// BOOST_CB_ENABLE_DEBUG: Debug support control. +#if defined(NDEBUG) || defined(BOOST_CB_DISABLE_DEBUG) + #define BOOST_CB_ENABLE_DEBUG 0 +#else + #define BOOST_CB_ENABLE_DEBUG 1 +#endif + +// BOOST_CB_ASSERT: Runtime assertion. +#if BOOST_CB_ENABLE_DEBUG + #include + #define BOOST_CB_ASSERT(Expr) BOOST_ASSERT(Expr) +#else + #define BOOST_CB_ASSERT(Expr) ((void)0) +#endif + +// BOOST_CB_IS_CONVERTIBLE: Check if Iterator::value_type is convertible to Type. +#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407) + #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) ((void)0) +#else + #include + #include + #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) \ + BOOST_STATIC_ASSERT((is_convertible::value_type, Type>::value)) +#endif + +// BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS: +// Check if the STL provides templated iterator constructors for its containers. +#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) + #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS BOOST_STATIC_ASSERT(false); +#else + #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS ((void)0); +#endif + +#include +#include +#include +#include + +#undef BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS +#undef BOOST_CB_IS_CONVERTIBLE +#undef BOOST_CB_ASSERT +#undef BOOST_CB_ENABLE_DEBUG + +#endif // #if !defined(BOOST_CIRCULAR_BUFFER_HPP) diff --git a/libktorrent/miniboost/boost/circular_buffer/base.hpp b/libktorrent/miniboost/boost/circular_buffer/base.hpp new file mode 100644 index 00000000..13c5d4b9 --- /dev/null +++ b/libktorrent/miniboost/boost/circular_buffer/base.hpp @@ -0,0 +1,3139 @@ +// Implementation of the base circular buffer. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright (c) 2013 Paul A. Bristow // Doxygen comments changed. +// Copyright (c) 2013 Antony Polukhin // Move semantics implementation. +// Copyright (c) 2014 Glen Fernandes // C++11 allocator model support. + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(BOOST_CIRCULAR_BUFFER_BASE_HPP) +#define BOOST_CIRCULAR_BUFFER_BASE_HPP + +#if defined(_MSC_VER) + #pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) + #include +#endif + +namespace boost { + +/*! + \class circular_buffer + \brief Circular buffer - a STL compliant container. + \tparam T The type of the elements stored in the circular_buffer. + \par Type Requirements T + The T has to be + SGIAssignable (SGI STL defined combination of + Assignable and CopyConstructible). + Moreover T has to be + DefaultConstructible if supplied as a default parameter when invoking some of the + circular_buffer's methods e.g. + insert(iterator pos, const value_type& item = %value_type()). And + EqualityComparable and/or + LessThanComparable if the circular_buffer + will be compared with another container. + \tparam Alloc The allocator type used for all internal memory management. + \par Type Requirements Alloc + The Alloc has to meet the allocator requirements imposed by STL. + \par Default Alloc + std::allocator + + For detailed documentation of the circular_buffer visit: + http://www.boost.org/libs/circular_buffer/doc/circular_buffer.html +*/ +template +class circular_buffer +/*! \cond */ +#if BOOST_CB_ENABLE_DEBUG +: public cb_details::debug_iterator_registry +#endif +/*! \endcond */ +{ + + // Requirements + //BOOST_CLASS_REQUIRE(T, boost, SGIAssignableConcept); + + + //BOOST_CONCEPT_ASSERT((Assignable)); + //BOOST_CONCEPT_ASSERT((CopyConstructible)); + //BOOST_CONCEPT_ASSERT((DefaultConstructible)); + + // Required if the circular_buffer will be compared with anther container. + //BOOST_CONCEPT_ASSERT((EqualityComparable)); + //BOOST_CONCEPT_ASSERT((LessThanComparable)); + +public: +// Basic types + + //! The type of this circular_buffer. + typedef circular_buffer this_type; + + //! The type of elements stored in the circular_buffer. + typedef typename boost::container::allocator_traits::value_type value_type; + + //! A pointer to an element. + typedef typename boost::container::allocator_traits::pointer pointer; + + //! A const pointer to the element. + typedef typename boost::container::allocator_traits::const_pointer const_pointer; + + //! A reference to an element. + typedef typename boost::container::allocator_traits::reference reference; + + //! A const reference to an element. + typedef typename boost::container::allocator_traits::const_reference const_reference; + + //! The distance type. + /*! + (A signed integral type used to represent the distance between two iterators.) + */ + typedef typename boost::container::allocator_traits::difference_type difference_type; + + //! The size type. + /*! + (An unsigned integral type that can represent any non-negative value of the container's distance type.) + */ + typedef typename boost::container::allocator_traits::size_type size_type; + + //! The type of an allocator used in the circular_buffer. + typedef Alloc allocator_type; + +// Iterators + + //! A const (random access) iterator used to iterate through the circular_buffer. + typedef cb_details::iterator< circular_buffer, cb_details::const_traits > > const_iterator; + + //! A (random access) iterator used to iterate through the circular_buffer. + typedef cb_details::iterator< circular_buffer, cb_details::nonconst_traits > > iterator; + + //! A const iterator used to iterate backwards through a circular_buffer. + typedef boost::reverse_iterator const_reverse_iterator; + + //! An iterator used to iterate backwards through a circular_buffer. + typedef boost::reverse_iterator reverse_iterator; + +// Container specific types + + //! An array range. + /*! + (A typedef for the std::pair where + its first element is a pointer to a beginning of an array and its second element represents + a size of the array.) + */ + typedef std::pair array_range; + + //! A range of a const array. + /*! + (A typedef for the std::pair where + its first element is a pointer to a beginning of a const array and its second element represents + a size of the const array.) + */ + typedef std::pair const_array_range; + + //! The capacity type. + /*! + (Same as size_type - defined for consistency with the __cbso class. + + */ + // circular_buffer_space_optimized.) + + typedef size_type capacity_type; + +// Helper types + + //! A type representing the "best" way to pass the value_type to a method. + typedef const value_type& param_value_type; + + //! A type representing rvalue from param type. + //! On compilers without rvalue references support this type is the Boost.Moves type used for emulation. + typedef BOOST_RV_REF(value_type) rvalue_type; + +private: + + // TODO: move to Boost.Move + /*! \cond */ + template + static inline typename boost::conditional< + ((boost::is_nothrow_move_constructible::value && boost::is_nothrow_move_assignable::value) || !boost::is_copy_constructible::value) +#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + && has_move_emulation_enabled::value +#endif + , + rvalue_type, + param_value_type + >::type move_if_noexcept(ValT& value) BOOST_NOEXCEPT { + return boost::move(value); + } + /*! \endcond */ + +// Member variables + + //! The internal buffer used for storing elements in the circular buffer. + pointer m_buff; + + //! The internal buffer's end (end of the storage space). + pointer m_end; + + //! The virtual beginning of the circular buffer. + pointer m_first; + + //! The virtual end of the circular buffer (one behind the last element). + pointer m_last; + + //! The number of items currently stored in the circular buffer. + size_type m_size; + + //! The allocator. + allocator_type m_alloc; + +// Friends +#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) + friend iterator; + friend const_iterator; +#else + template friend struct cb_details::iterator; +#endif + +public: +// Allocator + + //! Get the allocator. + /*! + \return The allocator. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa get_allocator() for obtaining an allocator %reference. + */ + allocator_type get_allocator() const BOOST_NOEXCEPT { return m_alloc; } + + //! Get the allocator reference. + /*! + \return A reference to the allocator. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \note This method was added in order to optimize obtaining of the allocator with a state, + although use of stateful allocators in STL is discouraged. + \sa get_allocator() const + */ + allocator_type& get_allocator() BOOST_NOEXCEPT { return m_alloc; } + +// Element access + + //! Get the iterator pointing to the beginning of the circular_buffer. + /*! + \return A random access iterator pointing to the first element of the circular_buffer. If the + circular_buffer is empty it returns an iterator equal to the one returned by + end(). + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa end(), rbegin(), rend() + */ + iterator begin() BOOST_NOEXCEPT { return iterator(this, empty() ? 0 : m_first); } + + //! Get the iterator pointing to the end of the circular_buffer. + /*! + \return A random access iterator pointing to the element "one behind" the last element of the + circular_buffer. If the circular_buffer is empty it returns an iterator equal to + the one returned by begin(). + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa begin(), rbegin(), rend() + */ + iterator end() BOOST_NOEXCEPT { return iterator(this, 0); } + + //! Get the const iterator pointing to the beginning of the circular_buffer. + /*! + \return A const random access iterator pointing to the first element of the circular_buffer. If + the circular_buffer is empty it returns an iterator equal to the one returned by + end() const. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa end() const, rbegin() const, rend() const + */ + const_iterator begin() const BOOST_NOEXCEPT { return const_iterator(this, empty() ? 0 : m_first); } + + //! Get the const iterator pointing to the end of the circular_buffer. + /*! + \return A const random access iterator pointing to the element "one behind" the last element of the + circular_buffer. If the circular_buffer is empty it returns an iterator equal to + the one returned by begin() const const. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa begin() const, rbegin() const, rend() const + */ + const_iterator end() const BOOST_NOEXCEPT { return const_iterator(this, 0); } + + //! Get the iterator pointing to the beginning of the "reversed" circular_buffer. + /*! + \return A reverse random access iterator pointing to the last element of the circular_buffer. + If the circular_buffer is empty it returns an iterator equal to the one returned by + rend(). + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa rend(), begin(), end() + */ + reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(end()); } + + //! Get the iterator pointing to the end of the "reversed" circular_buffer. + /*! + \return A reverse random access iterator pointing to the element "one before" the first element of the + circular_buffer. If the circular_buffer is empty it returns an iterator equal to + the one returned by rbegin(). + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa rbegin(), begin(), end() + */ + reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); } + + //! Get the const iterator pointing to the beginning of the "reversed" circular_buffer. + /*! + \return A const reverse random access iterator pointing to the last element of the + circular_buffer. If the circular_buffer is empty it returns an iterator equal + to the one returned by rend() const. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa rend() const, begin() const, end() const + */ + const_reverse_iterator rbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); } + + //! Get the const iterator pointing to the end of the "reversed" circular_buffer. + /*! + \return A const reverse random access iterator pointing to the element "one before" the first element of the + circular_buffer. If the circular_buffer is empty it returns an iterator equal + to the one returned by rbegin() const. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa rbegin() const, begin() const, end() const + */ + const_reverse_iterator rend() const BOOST_NOEXCEPT { return const_reverse_iterator(begin()); } + + //! Get the element at the index position. + /*! + \pre 0 \<= index \&\& index \< size() + \param index The position of the element. + \return A reference to the element at the index position. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa at() + */ + reference operator [] (size_type index) { + BOOST_CB_ASSERT(index < size()); // check for invalid index + return *add(m_first, index); + } + + //! Get the element at the index position. + /*! + \pre 0 \<= index \&\& index \< size() + \param index The position of the element. + \return A const reference to the element at the index position. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link at(size_type)const at() const \endlink + */ + const_reference operator [] (size_type index) const { + BOOST_CB_ASSERT(index < size()); // check for invalid index + return *add(m_first, index); + } + + //! Get the element at the index position. + /*! + \param index The position of the element. + \return A reference to the element at the index position. + \throws std::out_of_range when the index is invalid (when + index >= size()). + \par Exception Safety + Strong. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link operator[](size_type) operator[] \endlink + */ + reference at(size_type index) { + check_position(index); + return (*this)[index]; + } + + //! Get the element at the index position. + /*! + \param index The position of the element. + \return A const reference to the element at the index position. + \throws std::out_of_range when the index is invalid (when + index >= size()). + \par Exception Safety + Strong. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link operator[](size_type)const operator[] const \endlink + */ + const_reference at(size_type index) const { + check_position(index); + return (*this)[index]; + } + + //! Get the first element. + /*! + \pre !empty() + \return A reference to the first element of the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa back() + */ + reference front() { + BOOST_CB_ASSERT(!empty()); // check for empty buffer (front element not available) + return *m_first; + } + + //! Get the last element. + /*! + \pre !empty() + \return A reference to the last element of the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa front() + */ + reference back() { + BOOST_CB_ASSERT(!empty()); // check for empty buffer (back element not available) + return *((m_last == m_buff ? m_end : m_last) - 1); + } + + //! Get the first element. + /*! + \pre !empty() + \return A const reference to the first element of the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa back() const + */ + const_reference front() const { + BOOST_CB_ASSERT(!empty()); // check for empty buffer (front element not available) + return *m_first; + } + + //! Get the last element. + /*! + \pre !empty() + \return A const reference to the last element of the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa front() const + */ + const_reference back() const { + BOOST_CB_ASSERT(!empty()); // check for empty buffer (back element not available) + return *((m_last == m_buff ? m_end : m_last) - 1); + } + + //! Get the first continuous array of the internal buffer. + /*! + This method in combination with array_two() can be useful when passing the stored data into + a legacy C API as an array. Suppose there is a circular_buffer of capacity 10, containing 7 + characters 'a', 'b', ..., 'g' where buff[0] == 'a', buff[1] == 'b', + ... and buff[6] == 'g':

+ circular_buffer buff(10);

+ The internal representation is often not linear and the state of the internal buffer may look like this:
+
+ |e|f|g| | | |a|b|c|d|
+ end ___^
+ begin _______^

+ + where |a|b|c|d| represents the "array one", |e|f|g| represents the "array two" and + | | | | is a free space.
+ Now consider a typical C style function for writing data into a file:

+ int write(int file_desc, char* buff, int num_bytes);

+ There are two ways how to write the content of the circular_buffer into a file. Either relying + on array_one() and array_two() methods and calling the write function twice:

+ array_range ar = buff.array_one();
+ write(file_desc, ar.first, ar.second);
+ ar = buff.array_two();
+ write(file_desc, ar.first, ar.second);

+ Or relying on the linearize() method:

+ write(file_desc, buff.linearize(), buff.size());

+ Since the complexity of array_one() and array_two() methods is constant the first + option is suitable when calling the write method is "cheap". On the other hand the second option is more + suitable when calling the write method is more "expensive" than calling the linearize() method + whose complexity is linear. + \return The array range of the first continuous array of the internal buffer. In the case the + circular_buffer is empty the size of the returned array is 0. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \warning In general invoking any method which modifies the internal state of the circular_buffer may + delinearize the internal buffer and invalidate the array ranges returned by array_one() + and array_two() (and their const versions). + \note In the case the internal buffer is linear e.g. |a|b|c|d|e|f|g| | | | the "array one" is + represented by |a|b|c|d|e|f|g| and the "array two" does not exist (the + array_two() method returns an array with the size 0). + \sa array_two(), linearize() + */ + array_range array_one() { + return array_range(m_first, (m_last <= m_first && !empty() ? m_end : m_last) - m_first); + } + + //! Get the second continuous array of the internal buffer. + /*! + This method in combination with array_one() can be useful when passing the stored data into + a legacy C API as an array. + \return The array range of the second continuous array of the internal buffer. In the case the internal buffer + is linear or the circular_buffer is empty the size of the returned array is + 0. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa array_one() + */ + array_range array_two() { + return array_range(m_buff, m_last <= m_first && !empty() ? m_last - m_buff : 0); + } + + //! Get the first continuous array of the internal buffer. + /*! + This method in combination with array_two() const can be useful when passing the stored data into + a legacy C API as an array. + \return The array range of the first continuous array of the internal buffer. In the case the + circular_buffer is empty the size of the returned array is 0. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa array_two() const; array_one() for more details how to pass data into a legacy C + API. + */ + const_array_range array_one() const { + return const_array_range(m_first, (m_last <= m_first && !empty() ? m_end : m_last) - m_first); + } + + //! Get the second continuous array of the internal buffer. + /*! + This method in combination with array_one() const can be useful when passing the stored data into + a legacy C API as an array. + \return The array range of the second continuous array of the internal buffer. In the case the internal buffer + is linear or the circular_buffer is empty the size of the returned array is + 0. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa array_one() const + */ + const_array_range array_two() const { + return const_array_range(m_buff, m_last <= m_first && !empty() ? m_last - m_buff : 0); + } + + //! Linearize the internal buffer into a continuous array. + /*! + This method can be useful when passing the stored data into a legacy C API as an array. + \post \&(*this)[0] \< \&(*this)[1] \< ... \< \&(*this)[size() - 1] + \return A pointer to the beginning of the array or 0 if empty. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()); does not invalidate any iterators if the postcondition (the Effect) is already + met prior calling this method. + \par Complexity + Linear (in the size of the circular_buffer); constant if the postcondition (the + Effect) is already met. + \warning In general invoking any method which modifies the internal state of the circular_buffer + may delinearize the internal buffer and invalidate the returned pointer. + \sa array_one() and array_two() for the other option how to pass data into a legacy + C API; is_linearized(), rotate(const_iterator) + */ + pointer linearize() { + if (empty()) + return 0; + if (m_first < m_last || m_last == m_buff) + return m_first; + pointer src = m_first; + pointer dest = m_buff; + size_type moved = 0; + size_type constructed = 0; + BOOST_TRY { + for (pointer first = m_first; dest < src; src = first) { + for (size_type ii = 0; src < m_end; ++src, ++dest, ++moved, ++ii) { + if (moved == size()) { + first = dest; + break; + } + if (dest == first) { + first += ii; + break; + } + if (is_uninitialized(dest)) { + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*dest), this_type::move_if_noexcept(*src)); + ++constructed; + } else { + value_type tmp = this_type::move_if_noexcept(*src); + replace(src, this_type::move_if_noexcept(*dest)); + replace(dest, boost::move(tmp)); + } + } + } + } BOOST_CATCH(...) { + m_last += constructed; + m_size += constructed; + BOOST_RETHROW + } + BOOST_CATCH_END + for (src = m_end - constructed; src < m_end; ++src) + destroy_item(src); + m_first = m_buff; + m_last = add(m_buff, size()); +#if BOOST_CB_ENABLE_DEBUG + invalidate_iterators_except(end()); +#endif + return m_buff; + } + + //! Is the circular_buffer linearized? + /*! + \return true if the internal buffer is linearized into a continuous array (i.e. the + circular_buffer meets a condition + \&(*this)[0] \< \&(*this)[1] \< ... \< \&(*this)[size() - 1]); + false otherwise. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa linearize(), array_one(), array_two() + */ + bool is_linearized() const BOOST_NOEXCEPT { return m_first < m_last || m_last == m_buff; } + + //! Rotate elements in the circular_buffer. + /*! + A more effective implementation of + std::rotate. + \pre new_begin is a valid iterator pointing to the circular_buffer except its + end. + \post Before calling the method suppose:

+ m == std::distance(new_begin, end())
n == std::distance(begin(), new_begin) +
val_0 == *new_begin, val_1 == *(new_begin + 1), ... val_m == *(new_begin + m)
+ val_r1 == *(new_begin - 1), val_r2 == *(new_begin - 2), ... val_rn == *(new_begin - n)
+
then after call to the method:

+ val_0 == (*this)[0] \&\& val_1 == (*this)[1] \&\& ... \&\& val_m == (*this)[m - 1] \&\& val_r1 == + (*this)[m + n - 1] \&\& val_r2 == (*this)[m + n - 2] \&\& ... \&\& val_rn == (*this)[m] + \param new_begin The new beginning. + \throws See Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the circular_buffer is full or new_begin points to + begin() or if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + If m \< n invalidates iterators pointing to the last m elements + (including new_begin, but not iterators equal to end()) else invalidates + iterators pointing to the first n elements; does not invalidate any iterators if the + circular_buffer is full. + \par Complexity + Linear (in (std::min)(m, n)); constant if the circular_buffer is full. + \sa std::rotate + */ + void rotate(const_iterator new_begin) { + BOOST_CB_ASSERT(new_begin.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(new_begin.m_it != 0); // check for iterator pointing to end() + if (full()) { + m_first = m_last = const_cast(new_begin.m_it); + } else { + difference_type m = end() - new_begin; + difference_type n = new_begin - begin(); + if (m < n) { + for (; m > 0; --m) { + push_front(this_type::move_if_noexcept(back())); + pop_back(); + } + } else { + for (; n > 0; --n) { + push_back(this_type::move_if_noexcept(front())); + pop_front(); + } + } + } + } + +// Size and capacity + + //! Get the number of elements currently stored in the circular_buffer. + /*! + \return The number of elements stored in the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa capacity(), max_size(), reserve(), + \link resize() resize(size_type, const_reference)\endlink + */ + size_type size() const BOOST_NOEXCEPT { return m_size; } + + /*! \brief Get the largest possible size or capacity of the circular_buffer. (It depends on + allocator's %max_size()). + \return The maximum size/capacity the circular_buffer can be set to. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa size(), capacity(), reserve() + */ + size_type max_size() const BOOST_NOEXCEPT { + return (std::min)(boost::container::allocator_traits::max_size(m_alloc), (std::numeric_limits::max)()); + } + + //! Is the circular_buffer empty? + /*! + \return true if there are no elements stored in the circular_buffer; + false otherwise. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa full() + */ + bool empty() const BOOST_NOEXCEPT { return size() == 0; } + + //! Is the circular_buffer full? + /*! + \return true if the number of elements stored in the circular_buffer + equals the capacity of the circular_buffer; false otherwise. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa empty() + */ + bool full() const BOOST_NOEXCEPT { return capacity() == size(); } + + /*! \brief Get the maximum number of elements which can be inserted into the circular_buffer without + overwriting any of already stored elements. + \return capacity() - size() + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa capacity(), size(), max_size() + */ + size_type reserve() const BOOST_NOEXCEPT { return capacity() - size(); } + + //! Get the capacity of the circular_buffer. + /*! + \return The maximum number of elements which can be stored in the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Does not invalidate any iterators. + \par Complexity + Constant (in the size of the circular_buffer). + \sa reserve(), size(), max_size(), + set_capacity(capacity_type) + */ + capacity_type capacity() const BOOST_NOEXCEPT { return m_end - m_buff; } + + //! Change the capacity of the circular_buffer. + /*! + \pre If T is a move only type, then compiler shall support noexcept modifiers + and move constructor of T must be marked with it (must not throw exceptions). + \post capacity() == new_capacity \&\& size() \<= new_capacity

+ If the current number of elements stored in the circular_buffer is greater than the desired + new capacity then number of [size() - new_capacity] last elements will be removed and + the new size will be equal to new_capacity. + \param new_capacity The new capacity. + \throws "An allocation error" if memory is exhausted, (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept. + \par Exception Safety + Strong. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()) if the new capacity is different from the original. + \par Complexity + Linear (in min[size(), new_capacity]). + \sa rset_capacity(capacity_type), + \link resize() resize(size_type, const_reference)\endlink + */ + void set_capacity(capacity_type new_capacity) { + if (new_capacity == capacity()) + return; + pointer buff = allocate(new_capacity); + iterator b = begin(); + BOOST_TRY { + reset(buff, + cb_details::uninitialized_move_if_noexcept(b, b + (std::min)(new_capacity, size()), buff, m_alloc), + new_capacity); + } BOOST_CATCH(...) { + deallocate(buff, new_capacity); + BOOST_RETHROW + } + BOOST_CATCH_END + } + + //! Change the size of the circular_buffer. + /*! + \post size() == new_size \&\& capacity() >= new_size

+ If the new size is greater than the current size, copies of item will be inserted at the + back of the of the circular_buffer in order to achieve the desired size. In the case + the resulting size exceeds the current capacity the capacity will be set to new_size.
+ If the current number of elements stored in the circular_buffer is greater than the desired + new size then number of [size() - new_size] last elements will be removed. (The + capacity will remain unchanged.) + \param new_size The new size. + \param item The element the circular_buffer will be filled with in order to gain the requested + size. (See the Effect.) + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept. + \par Exception Safety + Basic. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()) if the new size is greater than the current capacity. Invalidates iterators pointing + to the removed elements if the new size is lower that the original size. Otherwise it does not invalidate + any iterator. + \par Complexity + Linear (in the new size of the circular_buffer). + \sa \link rresize() rresize(size_type, const_reference)\endlink, + set_capacity(capacity_type) + */ + void resize(size_type new_size, param_value_type item = value_type()) { + if (new_size > size()) { + if (new_size > capacity()) + set_capacity(new_size); + insert(end(), new_size - size(), item); + } else { + iterator e = end(); + erase(e - (size() - new_size), e); + } + } + + //! Change the capacity of the circular_buffer. + /*! + \pre If T is a move only type, then compiler shall support noexcept modifiers + and move constructor of T must be marked with it (must not throw exceptions). + \post capacity() == new_capacity \&\& size() \<= new_capacity

+ If the current number of elements stored in the circular_buffer is greater than the desired + new capacity then number of [size() - new_capacity] first elements will be removed + and the new size will be equal to new_capacity. + \param new_capacity The new capacity. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept. + \par Exception Safety + Strong. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()) if the new capacity is different from the original. + \par Complexity + Linear (in min[size(), new_capacity]). + \sa set_capacity(capacity_type), + \link rresize() rresize(size_type, const_reference)\endlink + */ + void rset_capacity(capacity_type new_capacity) { + if (new_capacity == capacity()) + return; + pointer buff = allocate(new_capacity); + iterator e = end(); + BOOST_TRY { + reset(buff, cb_details::uninitialized_move_if_noexcept(e - (std::min)(new_capacity, size()), + e, buff, m_alloc), new_capacity); + } BOOST_CATCH(...) { + deallocate(buff, new_capacity); + BOOST_RETHROW + } + BOOST_CATCH_END + } + + //! Change the size of the circular_buffer. + /*! + \post size() == new_size \&\& capacity() >= new_size

+ If the new size is greater than the current size, copies of item will be inserted at the + front of the of the circular_buffer in order to achieve the desired size. In the case + the resulting size exceeds the current capacity the capacity will be set to new_size.
+ If the current number of elements stored in the circular_buffer is greater than the desired + new size then number of [size() - new_size] first elements will be removed. (The + capacity will remain unchanged.) + \param new_size The new size. + \param item The element the circular_buffer will be filled with in order to gain the requested + size. (See the Effect.) + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept. + \par Exception Safety + Basic. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()) if the new size is greater than the current capacity. Invalidates iterators pointing + to the removed elements if the new size is lower that the original size. Otherwise it does not invalidate + any iterator. + \par Complexity + Linear (in the new size of the circular_buffer). + \sa \link resize() resize(size_type, const_reference)\endlink, + rset_capacity(capacity_type) + */ + void rresize(size_type new_size, param_value_type item = value_type()) { + if (new_size > size()) { + if (new_size > capacity()) + set_capacity(new_size); + rinsert(begin(), new_size - size(), item); + } else { + rerase(begin(), end() - new_size); + } + } + +// Construction/Destruction + + //! Create an empty circular_buffer with zero capacity. + /*! + \post capacity() == 0 \&\& size() == 0 + \param alloc The allocator. + \throws Nothing. + \par Complexity + Constant. + \warning Since Boost version 1.36 the behaviour of this constructor has changed. Now the constructor does not + allocate any memory and both capacity and size are set to zero. Also note when inserting an element + into a circular_buffer with zero capacity (e.g. by + \link push_back() push_back(const_reference)\endlink or + \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink) nothing + will be inserted and the size (as well as capacity) remains zero. + \note You can explicitly set the capacity by calling the set_capacity(capacity_type) method or you + can use the other constructor with the capacity specified. + \sa circular_buffer(capacity_type, const allocator_type& alloc), + set_capacity(capacity_type) + */ + explicit circular_buffer(const allocator_type& alloc = allocator_type()) BOOST_NOEXCEPT + : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(alloc) {} + + //! Create an empty circular_buffer with the specified capacity. + /*! + \post capacity() == buffer_capacity \&\& size() == 0 + \param buffer_capacity The maximum number of elements which can be stored in the circular_buffer. + \param alloc The allocator. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + \par Complexity + Constant. + */ + explicit circular_buffer(capacity_type buffer_capacity, const allocator_type& alloc = allocator_type()) + : m_size(0), m_alloc(alloc) { + initialize_buffer(buffer_capacity); + m_first = m_last = m_buff; + } + + /*! \brief Create a full circular_buffer with the specified capacity and filled with n + copies of item. + \post capacity() == n \&\& full() \&\& (*this)[0] == item \&\& (*this)[1] == item \&\& ... \&\& + (*this)[n - 1] == item + \param n The number of elements the created circular_buffer will be filled with. + \param item The element the created circular_buffer will be filled with. + \param alloc The allocator. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Complexity + Linear (in the n). + */ + circular_buffer(size_type n, param_value_type item, const allocator_type& alloc = allocator_type()) + : m_size(n), m_alloc(alloc) { + initialize_buffer(n, item); + m_first = m_last = m_buff; + } + + /*! \brief Create a circular_buffer with the specified capacity and filled with n + copies of item. + \pre buffer_capacity >= n + \post capacity() == buffer_capacity \&\& size() == n \&\& (*this)[0] == item \&\& (*this)[1] == item + \&\& ... \&\& (*this)[n - 1] == item + \param buffer_capacity The capacity of the created circular_buffer. + \param n The number of elements the created circular_buffer will be filled with. + \param item The element the created circular_buffer will be filled with. + \param alloc The allocator. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Complexity + Linear (in the n). + */ + circular_buffer(capacity_type buffer_capacity, size_type n, param_value_type item, + const allocator_type& alloc = allocator_type()) + : m_size(n), m_alloc(alloc) { + BOOST_CB_ASSERT(buffer_capacity >= size()); // check for capacity lower than size + initialize_buffer(buffer_capacity, item); + m_first = m_buff; + m_last = buffer_capacity == n ? m_buff : m_buff + n; + } + + //! The copy constructor. + /*! + Creates a copy of the specified circular_buffer. + \post *this == cb + \param cb The circular_buffer to be copied. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Complexity + Linear (in the size of cb). + */ + circular_buffer(const circular_buffer& cb) + : +#if BOOST_CB_ENABLE_DEBUG + debug_iterator_registry(), +#endif + m_size(cb.size()), m_alloc(cb.get_allocator()) { + initialize_buffer(cb.capacity()); + m_first = m_buff; + BOOST_TRY { + m_last = cb_details::uninitialized_copy(cb.begin(), cb.end(), m_buff, m_alloc); + } BOOST_CATCH(...) { + deallocate(m_buff, cb.capacity()); + BOOST_RETHROW + } + BOOST_CATCH_END + if (m_last == m_end) + m_last = m_buff; + } + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + //! The move constructor. + /*! \brief Move constructs a circular_buffer from cb, leaving cb empty. + \pre C++ compiler with rvalue references support. + \post cb.empty() + \param cb circular_buffer to 'steal' value from. + \throws Nothing. + \par Constant. + */ + circular_buffer(circular_buffer&& cb) BOOST_NOEXCEPT + : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(cb.get_allocator()) { + cb.swap(*this); + } +#endif // BOOST_NO_CXX11_RVALUE_REFERENCES + + //! Create a full circular_buffer filled with a copy of the range. + /*! + \pre Valid range [first, last).
+ first and last have to meet the requirements of + InputIterator. + \post capacity() == std::distance(first, last) \&\& full() \&\& (*this)[0]== *first \&\& + (*this)[1] == *(first + 1) \&\& ... \&\& (*this)[std::distance(first, last) - 1] == *(last - 1) + \param first The beginning of the range to be copied. + \param last The end of the range to be copied. + \param alloc The allocator. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Complexity + Linear (in the std::distance(first, last)). + */ + template + circular_buffer(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()) + : m_alloc(alloc) { + initialize(first, last, is_integral()); + } + + //! Create a circular_buffer with the specified capacity and filled with a copy of the range. + /*! + \pre Valid range [first, last).
+ first and last have to meet the requirements of + InputIterator. + \post capacity() == buffer_capacity \&\& size() \<= std::distance(first, last) \&\& + (*this)[0]== *(last - buffer_capacity) \&\& (*this)[1] == *(last - buffer_capacity + 1) \&\& ... \&\& + (*this)[buffer_capacity - 1] == *(last - 1)

+ If the number of items to be copied from the range [first, last) is greater than the + specified buffer_capacity then only elements from the range + [last - buffer_capacity, last) will be copied. + \param buffer_capacity The capacity of the created circular_buffer. + \param first The beginning of the range to be copied. + \param last The end of the range to be copied. + \param alloc The allocator. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Complexity + Linear (in std::distance(first, last); in + min[capacity, std::distance(first, last)] if the InputIterator is a + RandomAccessIterator). + */ + template + circular_buffer(capacity_type buffer_capacity, InputIterator first, InputIterator last, + const allocator_type& alloc = allocator_type()) + : m_alloc(alloc) { + initialize(buffer_capacity, first, last, is_integral()); + } + + //! The destructor. + /*! + Destroys the circular_buffer. + \throws Nothing. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (including iterators equal to + end()). + \par Complexity + Constant (in the size of the circular_buffer) for scalar types; linear for other types. + \sa clear() + */ + ~circular_buffer() BOOST_NOEXCEPT { + destroy(); +#if BOOST_CB_ENABLE_DEBUG + invalidate_all_iterators(); +#endif + } + +public: +// Assign methods + + //! The assign operator. + /*! + Makes this circular_buffer to become a copy of the specified circular_buffer. + \post *this == cb + \param cb The circular_buffer to be copied. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Exception Safety + Strong. + \par Iterator Invalidation + Invalidates all iterators pointing to this circular_buffer (except iterators equal to + end()). + \par Complexity + Linear (in the size of cb). + \sa \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink, + \link assign(capacity_type, size_type, param_value_type) + assign(capacity_type, size_type, const_reference)\endlink, + assign(InputIterator, InputIterator), + assign(capacity_type, InputIterator, InputIterator) + */ + circular_buffer& operator = (const circular_buffer& cb) { + if (this == &cb) + return *this; + pointer buff = allocate(cb.capacity()); + BOOST_TRY { + reset(buff, cb_details::uninitialized_copy(cb.begin(), cb.end(), buff, m_alloc), cb.capacity()); + } BOOST_CATCH(...) { + deallocate(buff, cb.capacity()); + BOOST_RETHROW + } + BOOST_CATCH_END + return *this; + } + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + /*! \brief Move assigns content of cb to *this, leaving cb empty. + \pre C++ compiler with rvalue references support. + \post cb.empty() + \param cb circular_buffer to 'steal' value from. + \throws Nothing. + \par Complexity + Constant. + */ + circular_buffer& operator = (circular_buffer&& cb) BOOST_NOEXCEPT { + cb.swap(*this); // now `this` holds `cb` + circular_buffer(get_allocator()) // temprary that holds initial `cb` allocator + .swap(cb); // makes `cb` empty + return *this; + } +#endif // BOOST_NO_CXX11_RVALUE_REFERENCES + + //! Assign n items into the circular_buffer. + /*! + The content of the circular_buffer will be removed and replaced with n copies of the + item. + \post capacity() == n \&\& size() == n \&\& (*this)[0] == item \&\& (*this)[1] == item \&\& ... \&\& + (*this) [n - 1] == item + \param n The number of elements the circular_buffer will be filled with. + \param item The element the circular_buffer will be filled with. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Exception Safety + Basic. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()). + \par Complexity + Linear (in the n). + \sa \link operator=(const circular_buffer&) operator=\endlink, + \link assign(capacity_type, size_type, param_value_type) + assign(capacity_type, size_type, const_reference)\endlink, + assign(InputIterator, InputIterator), + assign(capacity_type, InputIterator, InputIterator) + */ + void assign(size_type n, param_value_type item) { + assign_n(n, n, cb_details::assign_n(n, item, m_alloc)); + } + + //! Assign n items into the circular_buffer specifying the capacity. + /*! + The capacity of the circular_buffer will be set to the specified value and the content of the + circular_buffer will be removed and replaced with n copies of the item. + \pre capacity >= n + \post capacity() == buffer_capacity \&\& size() == n \&\& (*this)[0] == item \&\& (*this)[1] == item + \&\& ... \&\& (*this) [n - 1] == item + \param buffer_capacity The new capacity. + \param n The number of elements the circular_buffer will be filled with. + \param item The element the circular_buffer will be filled with. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Exception Safety + Basic. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()). + \par Complexity + Linear (in the n). + \sa \link operator=(const circular_buffer&) operator=\endlink, + \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink, + assign(InputIterator, InputIterator), + assign(capacity_type, InputIterator, InputIterator) + */ + void assign(capacity_type buffer_capacity, size_type n, param_value_type item) { + BOOST_CB_ASSERT(buffer_capacity >= n); // check for new capacity lower than n + assign_n(buffer_capacity, n, cb_details::assign_n(n, item, m_alloc)); + } + + //! Assign a copy of the range into the circular_buffer. + /*! + The content of the circular_buffer will be removed and replaced with copies of elements from the + specified range. + \pre Valid range [first, last).
+ first and last have to meet the requirements of + InputIterator. + \post capacity() == std::distance(first, last) \&\& size() == std::distance(first, last) \&\& + (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ... \&\& (*this)[std::distance(first, last) - 1] + == *(last - 1) + \param first The beginning of the range to be copied. + \param last The end of the range to be copied. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Exception Safety + Basic. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()). + \par Complexity + Linear (in the std::distance(first, last)). + \sa \link operator=(const circular_buffer&) operator=\endlink, + \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink, + \link assign(capacity_type, size_type, param_value_type) + assign(capacity_type, size_type, const_reference)\endlink, + assign(capacity_type, InputIterator, InputIterator) + */ + template + void assign(InputIterator first, InputIterator last) { + assign(first, last, is_integral()); + } + + //! Assign a copy of the range into the circular_buffer specifying the capacity. + /*! + The capacity of the circular_buffer will be set to the specified value and the content of the + circular_buffer will be removed and replaced with copies of elements from the specified range. + \pre Valid range [first, last).
+ first and last have to meet the requirements of + InputIterator. + \post capacity() == buffer_capacity \&\& size() \<= std::distance(first, last) \&\& + (*this)[0]== *(last - buffer_capacity) \&\& (*this)[1] == *(last - buffer_capacity + 1) \&\& ... \&\& + (*this)[buffer_capacity - 1] == *(last - 1)

+ If the number of items to be copied from the range [first, last) is greater than the + specified buffer_capacity then only elements from the range + [last - buffer_capacity, last) will be copied. + \param buffer_capacity The new capacity. + \param first The beginning of the range to be copied. + \param last The end of the range to be copied. + \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is + used). + Whatever T::T(const T&) throws. + \par Exception Safety + Basic. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()). + \par Complexity + Linear (in std::distance(first, last); in + min[capacity, std::distance(first, last)] if the InputIterator is a + RandomAccessIterator). + \sa \link operator=(const circular_buffer&) operator=\endlink, + \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink, + \link assign(capacity_type, size_type, param_value_type) + assign(capacity_type, size_type, const_reference)\endlink, + assign(InputIterator, InputIterator) + */ + template + void assign(capacity_type buffer_capacity, InputIterator first, InputIterator last) { + assign(buffer_capacity, first, last, is_integral()); + } + + //! Swap the contents of two circular_buffers. + /*! + \post this contains elements of cb and vice versa; the capacity of this + equals to the capacity of cb and vice versa. + \param cb The circular_buffer whose content will be swapped. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Invalidates all iterators of both circular_buffers. (On the other hand the iterators still + point to the same elements but within another container. If you want to rely on this feature you have to + turn the Debug Support off otherwise an assertion will report an error if such + invalidated iterator is used.) + \par Complexity + Constant (in the size of the circular_buffer). + \sa swap(circular_buffer&, circular_buffer&) + */ + void swap(circular_buffer& cb) BOOST_NOEXCEPT { + swap_allocator(cb, is_stateless()); + std::swap(m_buff, cb.m_buff); + std::swap(m_end, cb.m_end); + std::swap(m_first, cb.m_first); + std::swap(m_last, cb.m_last); + std::swap(m_size, cb.m_size); +#if BOOST_CB_ENABLE_DEBUG + invalidate_all_iterators(); + cb.invalidate_all_iterators(); +#endif + } + +// push and pop +private: + template + void push_back_impl(ValT item) { + if (full()) { + if (empty()) + return; + replace(m_last, static_cast(item)); + increment(m_last); + m_first = m_last; + } else { + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*m_last), static_cast(item)); + increment(m_last); + ++m_size; + } + } + + template + void push_front_impl(ValT item) { + BOOST_TRY { + if (full()) { + if (empty()) + return; + decrement(m_first); + replace(m_first, static_cast(item)); + m_last = m_first; + } else { + decrement(m_first); + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*m_first), static_cast(item)); + ++m_size; + } + } BOOST_CATCH(...) { + increment(m_first); + BOOST_RETHROW + } + BOOST_CATCH_END + } + +public: + //! Insert a new element at the end of the circular_buffer. + /*! + \post if capacity() > 0 then back() == item
+ If the circular_buffer is full, the first element will be removed. If the capacity is + 0, nothing will be inserted. + \param item The element to be inserted. + \throws Whatever T::T(const T&) throws. + Whatever T::operator = (const T&) throws. + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link push_front() push_front(const_reference)\endlink, + pop_back(), pop_front() + */ + void push_back(param_value_type item) { + push_back_impl(item); + } + + //! Insert a new element at the end of the circular_buffer using rvalue references or rvalues references emulation. + /*! + \post if capacity() > 0 then back() == item
+ If the circular_buffer is full, the first element will be removed. If the capacity is + 0, nothing will be inserted. + \param item The element to be inserted. + \throws Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link push_front() push_front(const_reference)\endlink, + pop_back(), pop_front() + */ + void push_back(rvalue_type item) { + push_back_impl(boost::move(item)); + } + + //! Insert a new default-constructed element at the end of the circular_buffer. + /*! + \post if capacity() > 0 then back() == item
+ If the circular_buffer is full, the first element will be removed. If the capacity is + 0, nothing will be inserted. + \throws Whatever T::T() throws. + Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link push_front() push_front(const_reference)\endlink, + pop_back(), pop_front() + */ + void push_back() { + value_type temp; + push_back(boost::move(temp)); + } + + //! Insert a new element at the beginning of the circular_buffer. + /*! + \post if capacity() > 0 then front() == item
+ If the circular_buffer is full, the last element will be removed. If the capacity is + 0, nothing will be inserted. + \param item The element to be inserted. + \throws Whatever T::T(const T&) throws. + Whatever T::operator = (const T&) throws. + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link push_back() push_back(const_reference)\endlink, + pop_back(), pop_front() + */ + void push_front(param_value_type item) { + push_front_impl(item); + } + + //! Insert a new element at the beginning of the circular_buffer using rvalue references or rvalues references emulation. + /*! + \post if capacity() > 0 then front() == item
+ If the circular_buffer is full, the last element will be removed. If the capacity is + 0, nothing will be inserted. + \param item The element to be inserted. + \throws Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link push_back() push_back(const_reference)\endlink, + pop_back(), pop_front() + */ + void push_front(rvalue_type item) { + push_front_impl(boost::move(item)); + } + + //! Insert a new default-constructed element at the beginning of the circular_buffer. + /*! + \post if capacity() > 0 then front() == item
+ If the circular_buffer is full, the last element will be removed. If the capacity is + 0, nothing will be inserted. + \throws Whatever T::T() throws. + Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Does not invalidate any iterators with the exception of iterators pointing to the overwritten element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa \link push_back() push_back(const_reference)\endlink, + pop_back(), pop_front() + */ + void push_front() { + value_type temp; + push_front(boost::move(temp)); + } + + //! Remove the last element from the circular_buffer. + /*! + \pre !empty() + \post The last element is removed from the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Invalidates only iterators pointing to the removed element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa pop_front(), \link push_back() push_back(const_reference)\endlink, + \link push_front() push_front(const_reference)\endlink + */ + void pop_back() { + BOOST_CB_ASSERT(!empty()); // check for empty buffer (back element not available) + decrement(m_last); + destroy_item(m_last); + --m_size; + } + + //! Remove the first element from the circular_buffer. + /*! + \pre !empty() + \post The first element is removed from the circular_buffer. + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Invalidates only iterators pointing to the removed element. + \par Complexity + Constant (in the size of the circular_buffer). + \sa pop_back(), \link push_back() push_back(const_reference)\endlink, + \link push_front() push_front(const_reference)\endlink + */ + void pop_front() { + BOOST_CB_ASSERT(!empty()); // check for empty buffer (front element not available) + destroy_item(m_first); + increment(m_first); + --m_size; + } +private: + template + iterator insert_impl(iterator pos, ValT item) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + iterator b = begin(); + if (full() && pos == b) + return b; + return insert_item(pos, static_cast(item)); + } + +public: +// Insert + + //! Insert an element at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The item will be inserted at the position pos.
+ If the circular_buffer is full, the first element will be overwritten. If the + circular_buffer is full and the pos points to begin(), then the + item will not be inserted. If the capacity is 0, nothing will be inserted. + \param pos An iterator specifying the position where the item will be inserted. + \param item The element to be inserted. + \return Iterator to the inserted element or begin() if the item is not inserted. (See + the Effect.) + \throws Whatever T::T(const T&) throws. + Whatever T::operator = (const T&) throws. + Exceptions of move_if_noexcept(T&). + + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements at the insertion point (including pos) and + iterators behind the insertion point (towards the end; except iterators equal to end()). It + also invalidates iterators pointing to the overwritten element. + \par Complexity + Linear (in std::distance(pos, end())). + \sa \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator), + \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink, + \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator) + */ + iterator insert(iterator pos, param_value_type item) { + return insert_impl(pos, item); + } + + //! Insert an element at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The item will be inserted at the position pos.
+ If the circular_buffer is full, the first element will be overwritten. If the + circular_buffer is full and the pos points to begin(), then the + item will not be inserted. If the capacity is 0, nothing will be inserted. + \param pos An iterator specifying the position where the item will be inserted. + \param item The element to be inserted. + \return Iterator to the inserted element or begin() if the item is not inserted. (See + the Effect.) + \throws Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements at the insertion point (including pos) and + iterators behind the insertion point (towards the end; except iterators equal to end()). It + also invalidates iterators pointing to the overwritten element. + \par Complexity + Linear (in std::distance(pos, end())). + \sa \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator), + \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink, + \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator) + */ + iterator insert(iterator pos, rvalue_type item) { + return insert_impl(pos, boost::move(item)); + } + + //! Insert a default-constructed element at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The item will be inserted at the position pos.
+ If the circular_buffer is full, the first element will be overwritten. If the + circular_buffer is full and the pos points to begin(), then the + item will not be inserted. If the capacity is 0, nothing will be inserted. + \param pos An iterator specifying the position where the item will be inserted. + \return Iterator to the inserted element or begin() if the item is not inserted. (See + the Effect.) + \throws Whatever T::T() throws. + Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements at the insertion point (including pos) and + iterators behind the insertion point (towards the end; except iterators equal to end()). It + also invalidates iterators pointing to the overwritten element. + \par Complexity + Linear (in std::distance(pos, end())). + \sa \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator), + \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink, + \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator) + */ + iterator insert(iterator pos) { + value_type temp; + return insert(pos, boost::move(temp)); + } + + //! Insert n copies of the item at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The number of min[n, (pos - begin()) + reserve()] elements will be inserted at the position + pos.
The number of min[pos - begin(), max[0, n - reserve()]] elements will + be overwritten at the beginning of the circular_buffer.
(See Example for the + explanation.) + \param pos An iterator specifying the position where the items will be inserted. + \param n The number of items the to be inserted. + \param item The element whose copies will be inserted. + \throws Whatever T::T(const T&) throws. + Whatever T::operator = (const T&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements at the insertion point (including pos) and + iterators behind the insertion point (towards the end; except iterators equal to end()). It + also invalidates iterators pointing to the overwritten elements. + \par Complexity + Linear (in min[capacity(), std::distance(pos, end()) + n]). + \par Example + Consider a circular_buffer with the capacity of 6 and the size of 4. Its internal buffer may + look like the one below.

+ |1|2|3|4| | |
+ p ___^

After inserting 5 elements at the position p:

+ insert(p, (size_t)5, 0);

actually only 4 elements get inserted and elements + 1 and 2 are overwritten. This is due to the fact the insert operation preserves + the capacity. After insertion the internal buffer looks like this:

|0|0|0|0|3|4|
+
For comparison if the capacity would not be preserved the internal buffer would then result in + |1|2|0|0|0|0|0|3|4|. + \sa \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink, + insert(iterator, InputIterator, InputIterator), + \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink, + \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator) + */ + void insert(iterator pos, size_type n, param_value_type item) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + if (n == 0) + return; + size_type copy = capacity() - (end() - pos); + if (copy == 0) + return; + if (n > copy) + n = copy; + insert_n(pos, n, cb_details::item_wrapper(item)); + } + + //! Insert the range [first, last) at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end.
+ Valid range [first, last) where first and last meet the + requirements of an InputIterator. + \post Elements from the range + [first + max[0, distance(first, last) - (pos - begin()) - reserve()], last) will be + inserted at the position pos.
The number of min[pos - begin(), max[0, + distance(first, last) - reserve()]] elements will be overwritten at the beginning of the + circular_buffer.
(See Example for the explanation.) + \param pos An iterator specifying the position where the range will be inserted. + \param first The beginning of the range to be inserted. + \param last The end of the range to be inserted. + \throws Whatever T::T(const T&) throws if the InputIterator is not a move iterator. + Whatever T::operator = (const T&) throws if the InputIterator is not a move iterator. + Whatever T::T(T&&) throws if the InputIterator is a move iterator. + Whatever T::operator = (T&&) throws if the InputIterator is a move iterator. + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements at the insertion point (including pos) and + iterators behind the insertion point (towards the end; except iterators equal to end()). It + also invalidates iterators pointing to the overwritten elements. + \par Complexity + Linear (in [std::distance(pos, end()) + std::distance(first, last)]; in + min[capacity(), std::distance(pos, end()) + std::distance(first, last)] if the + InputIterator is a + RandomAccessIterator). + \par Example + Consider a circular_buffer with the capacity of 6 and the size of 4. Its internal buffer may + look like the one below.

+ |1|2|3|4| | |
+ p ___^

After inserting a range of elements at the position p:

+ int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);

+ actually only elements 6, 7, 8 and 9 from the + specified range get inserted and elements 1 and 2 are overwritten. This is due + to the fact the insert operation preserves the capacity. After insertion the internal buffer looks like + this:

|6|7|8|9|3|4|

For comparison if the capacity would not be preserved the + internal buffer would then result in |1|2|5|6|7|8|9|3|4|. + \sa \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink, + \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, \link rinsert(iterator, param_value_type) + rinsert(iterator, value_type)\endlink, \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator) + */ + template + void insert(iterator pos, InputIterator first, InputIterator last) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + insert(pos, first, last, is_integral()); + } + +private: + template + iterator rinsert_impl(iterator pos, ValT item) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + if (full() && pos.m_it == 0) + return end(); + if (pos == begin()) { + BOOST_TRY { + decrement(m_first); + construct_or_replace(!full(), m_first, static_cast(item)); + } BOOST_CATCH(...) { + increment(m_first); + BOOST_RETHROW + } + BOOST_CATCH_END + pos.m_it = m_first; + } else { + pointer src = m_first; + pointer dest = m_first; + decrement(dest); + pos.m_it = map_pointer(pos.m_it); + bool construct = !full(); + BOOST_TRY { + while (src != pos.m_it) { + construct_or_replace(construct, dest, this_type::move_if_noexcept(*src)); + increment(src); + increment(dest); + construct = false; + } + decrement(pos.m_it); + replace(pos.m_it, static_cast(item)); + } BOOST_CATCH(...) { + if (!construct && !full()) { + decrement(m_first); + ++m_size; + } + BOOST_RETHROW + } + BOOST_CATCH_END + decrement(m_first); + } + if (full()) + m_last = m_first; + else + ++m_size; + return iterator(this, pos.m_it); + } + +public: + + //! Insert an element before the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The item will be inserted before the position pos.
+ If the circular_buffer is full, the last element will be overwritten. If the + circular_buffer is full and the pos points to end(), then the + item will not be inserted. If the capacity is 0, nothing will be inserted. + \param pos An iterator specifying the position before which the item will be inserted. + \param item The element to be inserted. + \return Iterator to the inserted element or end() if the item is not inserted. (See + the Effect.) + \throws Whatever T::T(const T&) throws. + Whatever T::operator = (const T&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements before the insertion point (towards the beginning and + excluding pos). It also invalidates iterators pointing to the overwritten element. + \par Complexity + Linear (in std::distance(begin(), pos)). + \sa \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator), + \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink, + \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator) + */ + iterator rinsert(iterator pos, param_value_type item) { + return rinsert_impl(pos, item); + } + + //! Insert an element before the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The item will be inserted before the position pos.
+ If the circular_buffer is full, the last element will be overwritten. If the + circular_buffer is full and the pos points to end(), then the + item will not be inserted. If the capacity is 0, nothing will be inserted. + \param pos An iterator specifying the position before which the item will be inserted. + \param item The element to be inserted. + \return Iterator to the inserted element or end() if the item is not inserted. (See + the Effect.) + \throws Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements before the insertion point (towards the beginning and + excluding pos). It also invalidates iterators pointing to the overwritten element. + \par Complexity + Linear (in std::distance(begin(), pos)). + \sa \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator), + \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink, + \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator) + */ + iterator rinsert(iterator pos, rvalue_type item) { + return rinsert_impl(pos, boost::move(item)); + } + + //! Insert an element before the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The item will be inserted before the position pos.
+ If the circular_buffer is full, the last element will be overwritten. If the + circular_buffer is full and the pos points to end(), then the + item will not be inserted. If the capacity is 0, nothing will be inserted. + \param pos An iterator specifying the position before which the item will be inserted. + \return Iterator to the inserted element or end() if the item is not inserted. (See + the Effect.) + \throws Whatever T::T() throws. + Whatever T::T(T&&) throws. + Whatever T::operator = (T&&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements before the insertion point (towards the beginning and + excluding pos). It also invalidates iterators pointing to the overwritten element. + \par Complexity + Linear (in std::distance(begin(), pos)). + \sa \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator), + \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink, + \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator) + */ + iterator rinsert(iterator pos) { + value_type temp; + return rinsert(pos, boost::move(temp)); + } + + //! Insert n copies of the item before the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end. + \post The number of min[n, (end() - pos) + reserve()] elements will be inserted before the + position pos.
The number of min[end() - pos, max[0, n - reserve()]] elements + will be overwritten at the end of the circular_buffer.
(See Example for the + explanation.) + \param pos An iterator specifying the position where the items will be inserted. + \param n The number of items the to be inserted. + \param item The element whose copies will be inserted. + \throws Whatever T::T(const T&) throws. + Whatever T::operator = (const T&) throws. + Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements before the insertion point (towards the beginning and + excluding pos). It also invalidates iterators pointing to the overwritten elements. + \par Complexity + Linear (in min[capacity(), std::distance(begin(), pos) + n]). + \par Example + Consider a circular_buffer with the capacity of 6 and the size of 4. Its internal buffer may + look like the one below.

+ |1|2|3|4| | |
+ p ___^

After inserting 5 elements before the position p:

+ rinsert(p, (size_t)5, 0);

actually only 4 elements get inserted and elements + 3 and 4 are overwritten. This is due to the fact the rinsert operation preserves + the capacity. After insertion the internal buffer looks like this:

|1|2|0|0|0|0|
+
For comparison if the capacity would not be preserved the internal buffer would then result in + |1|2|0|0|0|0|0|3|4|. + \sa \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink, + rinsert(iterator, InputIterator, InputIterator), + \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink, + \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator) + */ + void rinsert(iterator pos, size_type n, param_value_type item) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + rinsert_n(pos, n, cb_details::item_wrapper(item)); + } + + //! Insert the range [first, last) before the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer or its end.
+ Valid range [first, last) where first and last meet the + requirements of an InputIterator. + \post Elements from the range + [first, last - max[0, distance(first, last) - (end() - pos) - reserve()]) will be inserted + before the position pos.
The number of min[end() - pos, max[0, + distance(first, last) - reserve()]] elements will be overwritten at the end of the + circular_buffer.
(See Example for the explanation.) + \param pos An iterator specifying the position where the range will be inserted. + \param first The beginning of the range to be inserted. + \param last The end of the range to be inserted. + \throws Whatever T::T(const T&) throws if the InputIterator is not a move iterator. + Whatever T::operator = (const T&) throws if the InputIterator is not a move iterator. + Whatever T::T(T&&) throws if the InputIterator is a move iterator. + Whatever T::operator = (T&&) throws if the InputIterator is a move iterator. + \par Exception Safety + Basic; no-throw if the operations in the Throws section do not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the elements before the insertion point (towards the beginning and + excluding pos). It also invalidates iterators pointing to the overwritten elements. + \par Complexity + Linear (in [std::distance(begin(), pos) + std::distance(first, last)]; in + min[capacity(), std::distance(begin(), pos) + std::distance(first, last)] if the + InputIterator is a + RandomAccessIterator). + \par Example + Consider a circular_buffer with the capacity of 6 and the size of 4. Its internal buffer may + look like the one below.

+ |1|2|3|4| | |
+ p ___^

After inserting a range of elements before the position p:

+ int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);

+ actually only elements 5, 6, 7 and 8 from the + specified range get inserted and elements 3 and 4 are overwritten. This is due + to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks like + this:

|1|2|5|6|7|8|

For comparison if the capacity would not be preserved the + internal buffer would then result in |1|2|5|6|7|8|9|3|4|. + \sa \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink, + \link rinsert(iterator, size_type, param_value_type) + rinsert(iterator, size_type, value_type)\endlink, \link insert(iterator, param_value_type) + insert(iterator, value_type)\endlink, \link insert(iterator, size_type, param_value_type) + insert(iterator, size_type, value_type)\endlink, + insert(iterator, InputIterator, InputIterator) + */ + template + void rinsert(iterator pos, InputIterator first, InputIterator last) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + rinsert(pos, first, last, is_integral()); + } + +// Erase + + //! Remove an element at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer (but not an + end()). + \post The element at the position pos is removed. + \param pos An iterator pointing at the element to be removed. + \return Iterator to the first element remaining beyond the removed element or end() if no such + element exists. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the erased element and iterators pointing to the elements behind + the erased element (towards the end; except iterators equal to end()). + \par Complexity + Linear (in std::distance(pos, end())). + \sa erase(iterator, iterator), rerase(iterator), + rerase(iterator, iterator), erase_begin(size_type), + erase_end(size_type), clear() + */ + iterator erase(iterator pos) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(pos.m_it != 0); // check for iterator pointing to end() + pointer next = pos.m_it; + increment(next); + for (pointer p = pos.m_it; next != m_last; p = next, increment(next)) + replace(p, this_type::move_if_noexcept(*next)); + decrement(m_last); + destroy_item(m_last); + --m_size; +#if BOOST_CB_ENABLE_DEBUG + return m_last == pos.m_it ? end() : iterator(this, pos.m_it); +#else + return m_last == pos.m_it ? end() : pos; +#endif + } + + //! Erase the range [first, last). + /*! + \pre Valid range [first, last). + \post The elements from the range [first, last) are removed. (If first == last + nothing is removed.) + \param first The beginning of the range to be removed. + \param last The end of the range to be removed. + \return Iterator to the first element remaining beyond the removed elements or end() if no such + element exists. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the erased elements and iterators pointing to the elements behind + the erased range (towards the end; except iterators equal to end()). + \par Complexity + Linear (in std::distance(first, end())). + \sa erase(iterator), rerase(iterator), rerase(iterator, iterator), + erase_begin(size_type), erase_end(size_type), clear() + */ + iterator erase(iterator first, iterator last) { + BOOST_CB_ASSERT(first.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(last.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(first <= last); // check for wrong range + if (first == last) + return first; + pointer p = first.m_it; + while (last.m_it != 0) + replace((first++).m_it, this_type::move_if_noexcept(*last++)); + do { + decrement(m_last); + destroy_item(m_last); + --m_size; + } while(m_last != first.m_it); + return m_last == p ? end() : iterator(this, p); + } + + //! Remove an element at the specified position. + /*! + \pre pos is a valid iterator pointing to the circular_buffer (but not an + end()). + \post The element at the position pos is removed. + \param pos An iterator pointing at the element to be removed. + \return Iterator to the first element remaining in front of the removed element or begin() if no + such element exists. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the erased element and iterators pointing to the elements in front of + the erased element (towards the beginning). + \par Complexity + Linear (in std::distance(begin(), pos)). + \note This method is symetric to the erase(iterator) method and is more effective than + erase(iterator) if the iterator pos is close to the beginning of the + circular_buffer. (See the Complexity.) + \sa erase(iterator), erase(iterator, iterator), + rerase(iterator, iterator), erase_begin(size_type), + erase_end(size_type), clear() + */ + iterator rerase(iterator pos) { + BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(pos.m_it != 0); // check for iterator pointing to end() + pointer prev = pos.m_it; + pointer p = prev; + for (decrement(prev); p != m_first; p = prev, decrement(prev)) + replace(p, this_type::move_if_noexcept(*prev)); + destroy_item(m_first); + increment(m_first); + --m_size; +#if BOOST_CB_ENABLE_DEBUG + return p == pos.m_it ? begin() : iterator(this, pos.m_it); +#else + return p == pos.m_it ? begin() : pos; +#endif + } + + //! Erase the range [first, last). + /*! + \pre Valid range [first, last). + \post The elements from the range [first, last) are removed. (If first == last + nothing is removed.) + \param first The beginning of the range to be removed. + \param last The end of the range to be removed. + \return Iterator to the first element remaining in front of the removed elements or begin() if no + such element exists. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. + \par Iterator Invalidation + Invalidates iterators pointing to the erased elements and iterators pointing to the elements in front of + the erased range (towards the beginning). + \par Complexity + Linear (in std::distance(begin(), last)). + \note This method is symetric to the erase(iterator, iterator) method and is more effective than + erase(iterator, iterator) if std::distance(begin(), first) is lower that + std::distance(last, end()). + \sa erase(iterator), erase(iterator, iterator), rerase(iterator), + erase_begin(size_type), erase_end(size_type), clear() + */ + iterator rerase(iterator first, iterator last) { + BOOST_CB_ASSERT(first.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(last.is_valid(this)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(first <= last); // check for wrong range + if (first == last) + return first; + pointer p = map_pointer(last.m_it); + last.m_it = p; + while (first.m_it != m_first) { + decrement(first.m_it); + decrement(p); + replace(p, this_type::move_if_noexcept(*first.m_it)); + } + do { + destroy_item(m_first); + increment(m_first); + --m_size; + } while(m_first != p); + if (m_first == last.m_it) + return begin(); + decrement(last.m_it); + return iterator(this, last.m_it); + } + + //! Remove first n elements (with constant complexity for scalar types). + /*! + \pre n \<= size() + \post The n elements at the beginning of the circular_buffer will be removed. + \param n The number of elements to be removed. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. (I.e. no throw in + case of scalars.) + \par Iterator Invalidation + Invalidates iterators pointing to the first n erased elements. + \par Complexity + Constant (in n) for scalar types; linear for other types. + \note This method has been specially designed for types which do not require an explicit destructruction (e.g. + integer, float or a pointer). For these scalar types a call to a destructor is not required which makes + it possible to implement the "erase from beginning" operation with a constant complexity. For non-sacalar + types the complexity is linear (hence the explicit destruction is needed) and the implementation is + actually equivalent to + \link circular_buffer::rerase(iterator, iterator) rerase(begin(), begin() + n)\endlink. + \sa erase(iterator), erase(iterator, iterator), + rerase(iterator), rerase(iterator, iterator), + erase_end(size_type), clear() + */ + void erase_begin(size_type n) { + BOOST_CB_ASSERT(n <= size()); // check for n greater than size +#if BOOST_CB_ENABLE_DEBUG + erase_begin(n, false_type()); +#else + erase_begin(n, is_scalar()); +#endif + } + + //! Remove last n elements (with constant complexity for scalar types). + /*! + \pre n \<= size() + \post The n elements at the end of the circular_buffer will be removed. + \param n The number of elements to be removed. + \throws Exceptions of move_if_noexcept(T&). + \par Exception Safety + Basic; no-throw if the operation in the Throws section does not throw anything. (I.e. no throw in + case of scalars.) + \par Iterator Invalidation + Invalidates iterators pointing to the last n erased elements. + \par Complexity + Constant (in n) for scalar types; linear for other types. + \note This method has been specially designed for types which do not require an explicit destructruction (e.g. + integer, float or a pointer). For these scalar types a call to a destructor is not required which makes + it possible to implement the "erase from end" operation with a constant complexity. For non-sacalar + types the complexity is linear (hence the explicit destruction is needed) and the implementation is + actually equivalent to + \link circular_buffer::erase(iterator, iterator) erase(end() - n, end())\endlink. + \sa erase(iterator), erase(iterator, iterator), + rerase(iterator), rerase(iterator, iterator), + erase_begin(size_type), clear() + */ + void erase_end(size_type n) { + BOOST_CB_ASSERT(n <= size()); // check for n greater than size +#if BOOST_CB_ENABLE_DEBUG + erase_end(n, false_type()); +#else + erase_end(n, is_scalar()); +#endif + } + + //! Remove all stored elements from the circular_buffer. + /*! + \post size() == 0 + \throws Nothing. + \par Exception Safety + No-throw. + \par Iterator Invalidation + Invalidates all iterators pointing to the circular_buffer (except iterators equal to + end()). + \par Complexity + Constant (in the size of the circular_buffer) for scalar types; linear for other types. + \sa ~circular_buffer(), erase(iterator), erase(iterator, iterator), + rerase(iterator), rerase(iterator, iterator), + erase_begin(size_type), erase_end(size_type) + */ + void clear() BOOST_NOEXCEPT { + destroy_content(); + m_size = 0; + } + +private: +// Helper methods + + //! Check if the index is valid. + void check_position(size_type index) const { + if (index >= size()) + throw_exception(std::out_of_range("circular_buffer")); + } + + //! Increment the pointer. + template + void increment(Pointer& p) const { + if (++p == m_end) + p = m_buff; + } + + //! Decrement the pointer. + template + void decrement(Pointer& p) const { + if (p == m_buff) + p = m_end; + --p; + } + + //! Add n to the pointer. + template + Pointer add(Pointer p, difference_type n) const { + return p + (n < (m_end - p) ? n : n - capacity()); + } + + //! Subtract n from the pointer. + template + Pointer sub(Pointer p, difference_type n) const { + return p - (n > (p - m_buff) ? n - capacity() : n); + } + + //! Map the null pointer to virtual end of circular buffer. + pointer map_pointer(pointer p) const { return p == 0 ? m_last : p; } + + //! Allocate memory. + pointer allocate(size_type n) { + if (n > max_size()) + throw_exception(std::length_error("circular_buffer")); +#if BOOST_CB_ENABLE_DEBUG + pointer p = (n == 0) ? 0 : m_alloc.allocate(n); + cb_details::do_fill_uninitialized_memory(p, sizeof(value_type) * n); + return p; +#else + return (n == 0) ? 0 : m_alloc.allocate(n); +#endif + } + + //! Deallocate memory. + void deallocate(pointer p, size_type n) { + if (p != 0) + m_alloc.deallocate(p, n); + } + + //! Does the pointer point to the uninitialized memory? + bool is_uninitialized(const_pointer p) const BOOST_NOEXCEPT { + return p >= m_last && (m_first < m_last || p < m_first); + } + + //! Replace an element. + void replace(pointer pos, param_value_type item) { + *pos = item; +#if BOOST_CB_ENABLE_DEBUG + invalidate_iterators(iterator(this, pos)); +#endif + } + + //! Replace an element. + void replace(pointer pos, rvalue_type item) { + *pos = boost::move(item); +#if BOOST_CB_ENABLE_DEBUG + invalidate_iterators(iterator(this, pos)); +#endif + } + + //! Construct or replace an element. + /*! + construct has to be set to true if and only if + pos points to an uninitialized memory. + */ + void construct_or_replace(bool construct, pointer pos, param_value_type item) { + if (construct) + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*pos), item); + else + replace(pos, item); + } + + //! Construct or replace an element. + /*! + construct has to be set to true if and only if + pos points to an uninitialized memory. + */ + void construct_or_replace(bool construct, pointer pos, rvalue_type item) { + if (construct) + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*pos), boost::move(item)); + else + replace(pos, boost::move(item)); + } + + //! Destroy an item. + void destroy_item(pointer p) { + boost::container::allocator_traits::destroy(m_alloc, boost::addressof(*p)); +#if BOOST_CB_ENABLE_DEBUG + invalidate_iterators(iterator(this, p)); + cb_details::do_fill_uninitialized_memory(p, sizeof(value_type)); +#endif + } + + //! Destroy an item only if it has been constructed. + void destroy_if_constructed(pointer pos) { + if (is_uninitialized(pos)) + destroy_item(pos); + } + + //! Destroy the whole content of the circular buffer. + void destroy_content() { +#if BOOST_CB_ENABLE_DEBUG + destroy_content(false_type()); +#else + destroy_content(is_scalar()); +#endif + } + + //! Specialized destroy_content method. + void destroy_content(const true_type&) { + m_first = add(m_first, size()); + } + + //! Specialized destroy_content method. + void destroy_content(const false_type&) { + for (size_type ii = 0; ii < size(); ++ii, increment(m_first)) + destroy_item(m_first); + } + + //! Destroy content and free allocated memory. + void destroy() BOOST_NOEXCEPT { + destroy_content(); + deallocate(m_buff, capacity()); +#if BOOST_CB_ENABLE_DEBUG + m_buff = 0; + m_first = 0; + m_last = 0; + m_end = 0; +#endif + } + + //! Initialize the internal buffer. + void initialize_buffer(capacity_type buffer_capacity) { + m_buff = allocate(buffer_capacity); + m_end = m_buff + buffer_capacity; + } + + //! Initialize the internal buffer. + void initialize_buffer(capacity_type buffer_capacity, param_value_type item) { + initialize_buffer(buffer_capacity); + BOOST_TRY { + cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, m_alloc); + } BOOST_CATCH(...) { + deallocate(m_buff, size()); + BOOST_RETHROW + } + BOOST_CATCH_END + } + + //! Specialized initialize method. + template + void initialize(IntegralType n, IntegralType item, const true_type&) { + m_size = static_cast(n); + initialize_buffer(size(), item); + m_first = m_last = m_buff; + } + + //! Specialized initialize method. + template + void initialize(Iterator first, Iterator last, const false_type&) { + BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + initialize(first, last, iterator_category::type()); +#else + initialize(first, last, BOOST_DEDUCED_TYPENAME iterator_category::type()); +#endif + } + + //! Specialized initialize method. + template + void initialize(InputIterator first, InputIterator last, const std::input_iterator_tag&) { + BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS // check if the STL provides templated iterator constructors + // for containers + std::deque tmp(first, last, m_alloc); + size_type distance = tmp.size(); + initialize(distance, boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), distance); + } + + //! Specialized initialize method. + template + void initialize(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) { + BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range + size_type distance = std::distance(first, last); + initialize(distance, first, last, distance); + } + + //! Specialized initialize method. + template + void initialize(capacity_type buffer_capacity, IntegralType n, IntegralType item, const true_type&) { + BOOST_CB_ASSERT(buffer_capacity >= static_cast(n)); // check for capacity lower than n + m_size = static_cast(n); + initialize_buffer(buffer_capacity, item); + m_first = m_buff; + m_last = buffer_capacity == size() ? m_buff : m_buff + size(); + } + + //! Specialized initialize method. + template + void initialize(capacity_type buffer_capacity, Iterator first, Iterator last, const false_type&) { + BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + initialize(buffer_capacity, first, last, iterator_category::type()); +#else + initialize(buffer_capacity, first, last, BOOST_DEDUCED_TYPENAME iterator_category::type()); +#endif + } + + //! Specialized initialize method. + template + void initialize(capacity_type buffer_capacity, + InputIterator first, + InputIterator last, + const std::input_iterator_tag&) { + initialize_buffer(buffer_capacity); + m_first = m_last = m_buff; + m_size = 0; + if (buffer_capacity == 0) + return; + while (first != last && !full()) { + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*m_last), *first++); + increment(m_last); + ++m_size; + } + while (first != last) { + replace(m_last, *first++); + increment(m_last); + m_first = m_last; + } + } + + //! Specialized initialize method. + template + void initialize(capacity_type buffer_capacity, + ForwardIterator first, + ForwardIterator last, + const std::forward_iterator_tag&) { + BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range + initialize(buffer_capacity, first, last, std::distance(first, last)); + } + + //! Initialize the circular buffer. + template + void initialize(capacity_type buffer_capacity, + ForwardIterator first, + ForwardIterator last, + size_type distance) { + initialize_buffer(buffer_capacity); + m_first = m_buff; + if (distance > buffer_capacity) { + std::advance(first, distance - buffer_capacity); + m_size = buffer_capacity; + } else { + m_size = distance; + } + BOOST_TRY { + m_last = cb_details::uninitialized_copy(first, last, m_buff, m_alloc); + } BOOST_CATCH(...) { + deallocate(m_buff, buffer_capacity); + BOOST_RETHROW + } + BOOST_CATCH_END + if (m_last == m_end) + m_last = m_buff; + } + + //! Reset the circular buffer. + void reset(pointer buff, pointer last, capacity_type new_capacity) { + destroy(); + m_size = last - buff; + m_first = m_buff = buff; + m_end = m_buff + new_capacity; + m_last = last == m_end ? m_buff : last; + } + + //! Specialized method for swapping the allocator. + void swap_allocator(circular_buffer&, const true_type&) { + // Swap is not needed because allocators have no state. + } + + //! Specialized method for swapping the allocator. + void swap_allocator(circular_buffer& cb, const false_type&) { + std::swap(m_alloc, cb.m_alloc); + } + + //! Specialized assign method. + template + void assign(IntegralType n, IntegralType item, const true_type&) { + assign(static_cast(n), static_cast(item)); + } + + //! Specialized assign method. + template + void assign(Iterator first, Iterator last, const false_type&) { + BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + assign(first, last, iterator_category::type()); +#else + assign(first, last, BOOST_DEDUCED_TYPENAME iterator_category::type()); +#endif + } + + //! Specialized assign method. + template + void assign(InputIterator first, InputIterator last, const std::input_iterator_tag&) { + BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS // check if the STL provides templated iterator constructors + // for containers + std::deque tmp(first, last, m_alloc); + size_type distance = tmp.size(); + assign_n(distance, distance, + cb_details::make_assign_range + (boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), m_alloc)); + } + + //! Specialized assign method. + template + void assign(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) { + BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range + size_type distance = std::distance(first, last); + assign_n(distance, distance, cb_details::make_assign_range(first, last, m_alloc)); + } + + //! Specialized assign method. + template + void assign(capacity_type new_capacity, IntegralType n, IntegralType item, const true_type&) { + assign(new_capacity, static_cast(n), static_cast(item)); + } + + //! Specialized assign method. + template + void assign(capacity_type new_capacity, Iterator first, Iterator last, const false_type&) { + BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + assign(new_capacity, first, last, iterator_category::type()); +#else + assign(new_capacity, first, last, BOOST_DEDUCED_TYPENAME iterator_category::type()); +#endif + } + + //! Specialized assign method. + template + void assign(capacity_type new_capacity, InputIterator first, InputIterator last, const std::input_iterator_tag&) { + if (new_capacity == capacity()) { + clear(); + insert(begin(), first, last); + } else { + circular_buffer tmp(new_capacity, first, last, m_alloc); + tmp.swap(*this); + } + } + + //! Specialized assign method. + template + void assign(capacity_type new_capacity, ForwardIterator first, ForwardIterator last, + const std::forward_iterator_tag&) { + BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range + size_type distance = std::distance(first, last); + if (distance > new_capacity) { + std::advance(first, distance - new_capacity); + distance = new_capacity; + } + assign_n(new_capacity, distance, + cb_details::make_assign_range(first, last, m_alloc)); + } + + //! Helper assign method. + template + void assign_n(capacity_type new_capacity, size_type n, const Functor& fnc) { + if (new_capacity == capacity()) { + destroy_content(); + BOOST_TRY { + fnc(m_buff); + } BOOST_CATCH(...) { + m_size = 0; + BOOST_RETHROW + } + BOOST_CATCH_END + } else { + pointer buff = allocate(new_capacity); + BOOST_TRY { + fnc(buff); + } BOOST_CATCH(...) { + deallocate(buff, new_capacity); + BOOST_RETHROW + } + BOOST_CATCH_END + destroy(); + m_buff = buff; + m_end = m_buff + new_capacity; + } + m_size = n; + m_first = m_buff; + m_last = add(m_buff, size()); + } + + //! Helper insert method. + template + iterator insert_item(const iterator& pos, ValT item) { + pointer p = pos.m_it; + if (p == 0) { + construct_or_replace(!full(), m_last, static_cast(item)); + p = m_last; + } else { + pointer src = m_last; + pointer dest = m_last; + bool construct = !full(); + BOOST_TRY { + while (src != p) { + decrement(src); + construct_or_replace(construct, dest, this_type::move_if_noexcept(*src)); + decrement(dest); + construct = false; + } + replace(p, static_cast(item)); + } BOOST_CATCH(...) { + if (!construct && !full()) { + increment(m_last); + ++m_size; + } + BOOST_RETHROW + } + BOOST_CATCH_END + } + increment(m_last); + if (full()) + m_first = m_last; + else + ++m_size; + return iterator(this, p); + } + + //! Specialized insert method. + template + void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) { + insert(pos, static_cast(n), static_cast(item)); + } + + //! Specialized insert method. + template + void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) { + BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + insert(pos, first, last, iterator_category::type()); +#else + insert(pos, first, last, BOOST_DEDUCED_TYPENAME iterator_category::type()); +#endif + } + + //! Specialized insert method. + template + void insert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) { + if (!full() || pos != begin()) { + for (;first != last; ++pos) + pos = insert(pos, *first++); + } + } + + //! Specialized insert method. + template + void insert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) { + BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range + size_type n = std::distance(first, last); + if (n == 0) + return; + size_type copy = capacity() - (end() - pos); + if (copy == 0) + return; + if (n > copy) { + std::advance(first, n - copy); + n = copy; + } + insert_n(pos, n, cb_details::iterator_wrapper(first)); + } + + //! Helper insert method. + template + void insert_n(const iterator& pos, size_type n, const Wrapper& wrapper) { + size_type construct = reserve(); + if (construct > n) + construct = n; + if (pos.m_it == 0) { + size_type ii = 0; + pointer p = m_last; + BOOST_TRY { + for (; ii < construct; ++ii, increment(p)) + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*p), *wrapper()); + for (;ii < n; ++ii, increment(p)) + replace(p, *wrapper()); + } BOOST_CATCH(...) { + size_type constructed = (std::min)(ii, construct); + m_last = add(m_last, constructed); + m_size += constructed; + BOOST_RETHROW + } + BOOST_CATCH_END + } else { + pointer src = m_last; + pointer dest = add(m_last, n - 1); + pointer p = pos.m_it; + size_type ii = 0; + BOOST_TRY { + while (src != pos.m_it) { + decrement(src); + construct_or_replace(is_uninitialized(dest), dest, *src); + decrement(dest); + } + for (; ii < n; ++ii, increment(p)) + construct_or_replace(is_uninitialized(p), p, *wrapper()); + } BOOST_CATCH(...) { + for (p = add(m_last, n - 1); p != dest; decrement(p)) + destroy_if_constructed(p); + for (n = 0, p = pos.m_it; n < ii; ++n, increment(p)) + destroy_if_constructed(p); + BOOST_RETHROW + } + BOOST_CATCH_END + } + m_last = add(m_last, n); + m_first = add(m_first, n - construct); + m_size += construct; + } + + //! Specialized rinsert method. + template + void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) { + rinsert(pos, static_cast(n), static_cast(item)); + } + + //! Specialized rinsert method. + template + void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) { + BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) + rinsert(pos, first, last, iterator_category::type()); +#else + rinsert(pos, first, last, BOOST_DEDUCED_TYPENAME iterator_category::type()); +#endif + } + + //! Specialized insert method. + template + void rinsert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) { + if (!full() || pos.m_it != 0) { + for (;first != last; ++pos) { + pos = rinsert(pos, *first++); + if (pos.m_it == 0) + break; + } + } + } + + //! Specialized rinsert method. + template + void rinsert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) { + BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range + rinsert_n(pos, std::distance(first, last), cb_details::iterator_wrapper(first)); + } + + //! Helper rinsert method. + template + void rinsert_n(const iterator& pos, size_type n, const Wrapper& wrapper) { + if (n == 0) + return; + iterator b = begin(); + size_type copy = capacity() - (pos - b); + if (copy == 0) + return; + if (n > copy) + n = copy; + size_type construct = reserve(); + if (construct > n) + construct = n; + if (pos == b) { + pointer p = sub(m_first, n); + size_type ii = n; + BOOST_TRY { + for (;ii > construct; --ii, increment(p)) + replace(p, *wrapper()); + for (; ii > 0; --ii, increment(p)) + boost::container::allocator_traits::construct(m_alloc, boost::addressof(*p), *wrapper()); + } BOOST_CATCH(...) { + size_type constructed = ii < construct ? construct - ii : 0; + m_last = add(m_last, constructed); + m_size += constructed; + BOOST_RETHROW + } + BOOST_CATCH_END + } else { + pointer src = m_first; + pointer dest = sub(m_first, n); + pointer p = map_pointer(pos.m_it); + BOOST_TRY { + while (src != p) { + construct_or_replace(is_uninitialized(dest), dest, *src); + increment(src); + increment(dest); + } + for (size_type ii = 0; ii < n; ++ii, increment(dest)) + construct_or_replace(is_uninitialized(dest), dest, *wrapper()); + } BOOST_CATCH(...) { + for (src = sub(m_first, n); src != dest; increment(src)) + destroy_if_constructed(src); + BOOST_RETHROW + } + BOOST_CATCH_END + } + m_first = sub(m_first, n); + m_last = sub(m_last, n - construct); + m_size += construct; + } + + //! Specialized erase_begin method. + void erase_begin(size_type n, const true_type&) { + m_first = add(m_first, n); + m_size -= n; + } + + //! Specialized erase_begin method. + void erase_begin(size_type n, const false_type&) { + iterator b = begin(); + rerase(b, b + n); + } + + //! Specialized erase_end method. + void erase_end(size_type n, const true_type&) { + m_last = sub(m_last, n); + m_size -= n; + } + + //! Specialized erase_end method. + void erase_end(size_type n, const false_type&) { + iterator e = end(); + erase(e - n, e); + } +}; + +// Non-member functions + +//! Compare two circular_buffers element-by-element to determine if they are equal. +/*! + \param lhs The circular_buffer to compare. + \param rhs The circular_buffer to compare. + \return lhs.\link circular_buffer::size() size()\endlink == rhs.\link circular_buffer::size() size()\endlink + && std::equal(lhs.\link circular_buffer::begin() + begin()\endlink, lhs.\link circular_buffer::end() end()\endlink, + rhs.\link circular_buffer::begin() begin()\endlink) + \throws Nothing. + \par Complexity + Linear (in the size of the circular_buffers). + \par Iterator Invalidation + Does not invalidate any iterators. +*/ +template +inline bool operator == (const circular_buffer& lhs, const circular_buffer& rhs) { + return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); +} + +/*! + \brief Compare two circular_buffers element-by-element to determine if the left one is lesser than the + right one. + \param lhs The circular_buffer to compare. + \param rhs The circular_buffer to compare. + \return + std::lexicographical_compare(lhs.\link circular_buffer::begin() begin()\endlink, + lhs.\link circular_buffer::end() end()\endlink, rhs.\link circular_buffer::begin() begin()\endlink, + rhs.\link circular_buffer::end() end()\endlink) + \throws Nothing. + \par Complexity + Linear (in the size of the circular_buffers). + \par Iterator Invalidation + Does not invalidate any iterators. +*/ +template +inline bool operator < (const circular_buffer& lhs, const circular_buffer& rhs) { + return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); +} + +#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || defined(BOOST_MSVC) + +//! Compare two circular_buffers element-by-element to determine if they are non-equal. +/*! + \param lhs The circular_buffer to compare. + \param rhs The circular_buffer to compare. + \return !(lhs == rhs) + \throws Nothing. + \par Complexity + Linear (in the size of the circular_buffers). + \par Iterator Invalidation + Does not invalidate any iterators. + \sa operator==(const circular_buffer&, const circular_buffer&) +*/ +template +inline bool operator != (const circular_buffer& lhs, const circular_buffer& rhs) { + return !(lhs == rhs); +} + +/*! + \brief Compare two circular_buffers element-by-element to determine if the left one is greater than + the right one. + \param lhs The circular_buffer to compare. + \param rhs The circular_buffer to compare. + \return rhs \< lhs + \throws Nothing. + \par Complexity + Linear (in the size of the circular_buffers). + \par Iterator Invalidation + Does not invalidate any iterators. + \sa operator<(const circular_buffer&, const circular_buffer&) +*/ +template +inline bool operator > (const circular_buffer& lhs, const circular_buffer& rhs) { + return rhs < lhs; +} + +/*! + \brief Compare two circular_buffers element-by-element to determine if the left one is lesser or equal + to the right one. + \param lhs The circular_buffer to compare. + \param rhs The circular_buffer to compare. + \return !(rhs \< lhs) + \throws Nothing. + \par Complexity + Linear (in the size of the circular_buffers). + \par Iterator Invalidation + Does not invalidate any iterators. + \sa operator<(const circular_buffer&, const circular_buffer&) +*/ +template +inline bool operator <= (const circular_buffer& lhs, const circular_buffer& rhs) { + return !(rhs < lhs); +} + +/*! + \brief Compare two circular_buffers element-by-element to determine if the left one is greater or + equal to the right one. + \param lhs The circular_buffer to compare. + \param rhs The circular_buffer to compare. + \return !(lhs < rhs) + \throws Nothing. + \par Complexity + Linear (in the size of the circular_buffers). + \par Iterator Invalidation + Does not invalidate any iterators. + \sa operator<(const circular_buffer&, const circular_buffer&) +*/ +template +inline bool operator >= (const circular_buffer& lhs, const circular_buffer& rhs) { + return !(lhs < rhs); +} + +//! Swap the contents of two circular_buffers. +/*! + \post lhs contains elements of rhs and vice versa. + \param lhs The circular_buffer whose content will be swapped with rhs. + \param rhs The circular_buffer whose content will be swapped with lhs. + \throws Nothing. + \par Complexity + Constant (in the size of the circular_buffers). + \par Iterator Invalidation + Invalidates all iterators of both circular_buffers. (On the other hand the iterators still + point to the same elements but within another container. If you want to rely on this feature you have to + turn the Debug Support off otherwise an assertion will report an error if such + invalidated iterator is used.) + \sa \link circular_buffer::swap(circular_buffer&) swap(circular_buffer&)\endlink +*/ +template +inline void swap(circular_buffer& lhs, circular_buffer& rhs) BOOST_NOEXCEPT { + lhs.swap(rhs); +} + +#endif // #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || defined(BOOST_MSVC) + +} // namespace boost + +#endif // #if !defined(BOOST_CIRCULAR_BUFFER_BASE_HPP) diff --git a/libktorrent/miniboost/boost/circular_buffer/debug.hpp b/libktorrent/miniboost/boost/circular_buffer/debug.hpp new file mode 100644 index 00000000..b6ab0fef --- /dev/null +++ b/libktorrent/miniboost/boost/circular_buffer/debug.hpp @@ -0,0 +1,248 @@ +// Debug support for the circular buffer library. + +// Copyright (c) 2003-2008 Jan Gaspar + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(BOOST_CIRCULAR_BUFFER_DEBUG_HPP) +#define BOOST_CIRCULAR_BUFFER_DEBUG_HPP + +#if defined(_MSC_VER) + #pragma once +#endif + +#if BOOST_CB_ENABLE_DEBUG +#include + +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std { + using ::memset; +} +#endif + +#endif // BOOST_CB_ENABLE_DEBUG +namespace boost { + +namespace cb_details { + +#if BOOST_CB_ENABLE_DEBUG + +// The value the uninitialized memory is filled with. +const int UNINITIALIZED = 0xcc; + +template +inline void do_fill_uninitialized_memory(T* data, std::size_t size_in_bytes) BOOST_NOEXCEPT { + std::memset(static_cast(data), UNINITIALIZED, size_in_bytes); +} + +template +inline void do_fill_uninitialized_memory(T& /*data*/, std::size_t /*size_in_bytes*/) BOOST_NOEXCEPT { + // Do nothing +} + + +class debug_iterator_registry; + +/*! + \class debug_iterator_base + \brief Registers/unregisters iterators into the registry of valid iterators. + + This class is intended to be a base class of an iterator. +*/ +class debug_iterator_base { + +private: +// Members + + //! Iterator registry. + mutable const debug_iterator_registry* m_registry; + + //! Next iterator in the iterator chain. + mutable const debug_iterator_base* m_next; + +public: +// Construction/destruction + + //! Default constructor. + debug_iterator_base(); + + //! Constructor taking the iterator registry as a parameter. + debug_iterator_base(const debug_iterator_registry* registry); + + //! Copy constructor. + debug_iterator_base(const debug_iterator_base& rhs); + + //! Destructor. + ~debug_iterator_base(); + +// Methods + + //! Assign operator. + debug_iterator_base& operator = (const debug_iterator_base& rhs); + + //! Is the iterator valid? + bool is_valid(const debug_iterator_registry* registry) const; + + //! Invalidate the iterator. + /*! + \note The method is const in order to invalidate const iterators, too. + */ + void invalidate() const; + + //! Return the next iterator in the iterator chain. + const debug_iterator_base* next() const; + + //! Set the next iterator in the iterator chain. + /*! + \note The method is const in order to set a next iterator to a const iterator, too. + */ + void set_next(const debug_iterator_base* it) const; + +private: +// Helpers + + //! Register self as a valid iterator. + void register_self(); + + //! Unregister self from valid iterators. + void unregister_self(); +}; + +/*! + \class debug_iterator_registry + \brief Registry of valid iterators. + + This class is intended to be a base class of a container. +*/ +class debug_iterator_registry { + + //! Pointer to the chain of valid iterators. + mutable const debug_iterator_base* m_iterators; + +public: +// Methods + + //! Default constructor. + debug_iterator_registry() : m_iterators(0) {} + + //! Register an iterator into the list of valid iterators. + /*! + \note The method is const in order to register iterators into const containers, too. + */ + void register_iterator(const debug_iterator_base* it) const { + it->set_next(m_iterators); + m_iterators = it; + } + + //! Unregister an iterator from the list of valid iterators. + /*! + \note The method is const in order to unregister iterators from const containers, too. + */ + void unregister_iterator(const debug_iterator_base* it) const { + const debug_iterator_base* previous = 0; + for (const debug_iterator_base* p = m_iterators; p != it; previous = p, p = p->next()) {} + remove(it, previous); + } + + //! Invalidate every iterator pointing to the same element as the iterator passed as a parameter. + template + void invalidate_iterators(const Iterator& it) { + const debug_iterator_base* previous = 0; + for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) { + if (((Iterator*)p)->m_it == it.m_it) { + p->invalidate(); + remove(p, previous); + continue; + } + previous = p; + } + } + + //! Invalidate all iterators except an iterator poining to the same element as the iterator passed as a parameter. + template + void invalidate_iterators_except(const Iterator& it) { + const debug_iterator_base* previous = 0; + for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) { + if (((Iterator*)p)->m_it != it.m_it) { + p->invalidate(); + remove(p, previous); + continue; + } + previous = p; + } + } + + //! Invalidate all iterators. + void invalidate_all_iterators() { + for (const debug_iterator_base* p = m_iterators; p != 0; p = p->next()) + p->invalidate(); + m_iterators = 0; + } + +private: +// Helpers + + //! Remove the current iterator from the iterator chain. + void remove(const debug_iterator_base* current, + const debug_iterator_base* previous) const { + if (previous == 0) + m_iterators = m_iterators->next(); + else + previous->set_next(current->next()); + } +}; + +// Implementation of the debug_iterator_base methods. + +inline debug_iterator_base::debug_iterator_base() : m_registry(0), m_next(0) {} + +inline debug_iterator_base::debug_iterator_base(const debug_iterator_registry* registry) +: m_registry(registry), m_next(0) { + register_self(); +} + +inline debug_iterator_base::debug_iterator_base(const debug_iterator_base& rhs) +: m_registry(rhs.m_registry), m_next(0) { + register_self(); +} + +inline debug_iterator_base::~debug_iterator_base() { unregister_self(); } + +inline debug_iterator_base& debug_iterator_base::operator = (const debug_iterator_base& rhs) { + if (m_registry == rhs.m_registry) + return *this; + unregister_self(); + m_registry = rhs.m_registry; + register_self(); + return *this; +} + +inline bool debug_iterator_base::is_valid(const debug_iterator_registry* registry) const { + return m_registry == registry; +} + +inline void debug_iterator_base::invalidate() const { m_registry = 0; } + +inline const debug_iterator_base* debug_iterator_base::next() const { return m_next; } + +inline void debug_iterator_base::set_next(const debug_iterator_base* it) const { m_next = it; } + +inline void debug_iterator_base::register_self() { + if (m_registry != 0) + m_registry->register_iterator(this); +} + +inline void debug_iterator_base::unregister_self() { + if (m_registry != 0) + m_registry->unregister_iterator(this); +} + +#endif // #if BOOST_CB_ENABLE_DEBUG + +} // namespace cb_details + +} // namespace boost + +#endif // #if !defined(BOOST_CIRCULAR_BUFFER_DEBUG_HPP) diff --git a/libktorrent/miniboost/boost/circular_buffer/details.hpp b/libktorrent/miniboost/boost/circular_buffer/details.hpp new file mode 100644 index 00000000..44ca9c96 --- /dev/null +++ b/libktorrent/miniboost/boost/circular_buffer/details.hpp @@ -0,0 +1,499 @@ +// Helper classes and functions for the circular buffer. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright (c) 2014 Glen Fernandes // C++11 allocator model support. + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(BOOST_CIRCULAR_BUFFER_DETAILS_HPP) +#define BOOST_CIRCULAR_BUFFER_DETAILS_HPP + +#if defined(_MSC_VER) + #pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +// Silence MS /W4 warnings like C4913: +// "user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used" +// This might happen when previously including some boost headers that overload the coma operator. +#if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4913) +#endif + +namespace boost { + +namespace cb_details { + +template struct nonconst_traits; + +template +void uninitialized_fill_n_with_alloc( + ForwardIterator first, Diff n, const T& item, Alloc& alloc); + +template +ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a); + +template +ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a); + +/*! + \struct const_traits + \brief Defines the data types for a const iterator. +*/ +template +struct const_traits { + // Basic types + typedef typename Traits::value_type value_type; + typedef typename Traits::const_pointer pointer; + typedef typename Traits::const_reference reference; + typedef typename Traits::size_type size_type; + typedef typename Traits::difference_type difference_type; + + // Non-const traits + typedef nonconst_traits nonconst_self; +}; + +/*! + \struct nonconst_traits + \brief Defines the data types for a non-const iterator. +*/ +template +struct nonconst_traits { + // Basic types + typedef typename Traits::value_type value_type; + typedef typename Traits::pointer pointer; + typedef typename Traits::reference reference; + typedef typename Traits::size_type size_type; + typedef typename Traits::difference_type difference_type; + + // Non-const traits + typedef nonconst_traits nonconst_self; +}; + +/*! + \struct iterator_wrapper + \brief Helper iterator dereference wrapper. +*/ +template +struct iterator_wrapper { + mutable Iterator m_it; + explicit iterator_wrapper(Iterator it) : m_it(it) {} + Iterator operator () () const { return m_it++; } +private: + iterator_wrapper& operator = (const iterator_wrapper&); // do not generate +}; + +/*! + \struct item_wrapper + \brief Helper item dereference wrapper. +*/ +template +struct item_wrapper { + Value m_item; + explicit item_wrapper(Value item) : m_item(item) {} + Pointer operator () () const { return &m_item; } +private: + item_wrapper& operator = (const item_wrapper&); // do not generate +}; + +/*! + \struct assign_n + \brief Helper functor for assigning n items. +*/ +template +struct assign_n { + typedef typename boost::container::allocator_traits::size_type size_type; + size_type m_n; + Value m_item; + Alloc& m_alloc; + assign_n(size_type n, Value item, Alloc& alloc) : m_n(n), m_item(item), m_alloc(alloc) {} + template + void operator () (Pointer p) const { + uninitialized_fill_n_with_alloc(p, m_n, m_item, m_alloc); + } +private: + assign_n& operator = (const assign_n&); // do not generate +}; + +/*! + \struct assign_range + \brief Helper functor for assigning range of items. +*/ +template +struct assign_range { + Iterator m_first; + Iterator m_last; + Alloc& m_alloc; + + assign_range(const Iterator& first, const Iterator& last, Alloc& alloc) + : m_first(first), m_last(last), m_alloc(alloc) {} + + template + void operator () (Pointer p) const { + boost::cb_details::uninitialized_copy(m_first, m_last, p, m_alloc); + } +}; + +template +inline assign_range make_assign_range(const Iterator& first, const Iterator& last, Alloc& a) { + return assign_range(first, last, a); +} + +/*! + \class capacity_control + \brief Capacity controller of the space optimized circular buffer. +*/ +template +class capacity_control { + + //! The capacity of the space-optimized circular buffer. + Size m_capacity; + + //! The lowest guaranteed or minimum capacity of the adapted space-optimized circular buffer. + Size m_min_capacity; + +public: + + //! Constructor. + capacity_control(Size buffer_capacity, Size min_buffer_capacity = 0) + : m_capacity(buffer_capacity), m_min_capacity(min_buffer_capacity) + { // Check for capacity lower than min_capacity. + BOOST_CB_ASSERT(buffer_capacity >= min_buffer_capacity); + } + + // Default copy constructor. + + // Default assign operator. + + //! Get the capacity of the space optimized circular buffer. + Size capacity() const { return m_capacity; } + + //! Get the minimal capacity of the space optimized circular buffer. + Size min_capacity() const { return m_min_capacity; } + + //! Size operator - returns the capacity of the space optimized circular buffer. + operator Size() const { return m_capacity; } +}; + +/*! + \struct iterator + \brief Random access iterator for the circular buffer. + \param Buff The type of the underlying circular buffer. + \param Traits Basic iterator types. + \note This iterator is not circular. It was designed + for iterating from begin() to end() of the circular buffer. +*/ +template +struct iterator : + public boost::iterator< + std::random_access_iterator_tag, + typename Traits::value_type, + typename Traits::difference_type, + typename Traits::pointer, + typename Traits::reference> +#if BOOST_CB_ENABLE_DEBUG + , public debug_iterator_base +#endif // #if BOOST_CB_ENABLE_DEBUG +{ +// Helper types + + //! Base iterator. + typedef boost::iterator< + std::random_access_iterator_tag, + typename Traits::value_type, + typename Traits::difference_type, + typename Traits::pointer, + typename Traits::reference> base_iterator; + + //! Non-const iterator. + typedef iterator nonconst_self; + +// Basic types + + //! The type of the elements stored in the circular buffer. + typedef typename base_iterator::value_type value_type; + + //! Pointer to the element. + typedef typename base_iterator::pointer pointer; + + //! Reference to the element. + typedef typename base_iterator::reference reference; + + //! Size type. + typedef typename Traits::size_type size_type; + + //! Difference type. + typedef typename base_iterator::difference_type difference_type; + +// Member variables + + //! The circular buffer where the iterator points to. + const Buff* m_buff; + + //! An internal iterator. + pointer m_it; + +// Construction & assignment + + // Default copy constructor. + + //! Default constructor. + iterator() : m_buff(0), m_it(0) {} + +#if BOOST_CB_ENABLE_DEBUG + + //! Copy constructor (used for converting from a non-const to a const iterator). + iterator(const nonconst_self& it) : debug_iterator_base(it), m_buff(it.m_buff), m_it(it.m_it) {} + + //! Internal constructor. + /*! + \note This constructor is not intended to be used directly by the user. + */ + iterator(const Buff* cb, const pointer p) : debug_iterator_base(cb), m_buff(cb), m_it(p) {} + +#else + + iterator(const nonconst_self& it) : m_buff(it.m_buff), m_it(it.m_it) {} + + iterator(const Buff* cb, const pointer p) : m_buff(cb), m_it(p) {} + +#endif // #if BOOST_CB_ENABLE_DEBUG + + //! Assign operator. + iterator& operator = (const iterator& it) { + if (this == &it) + return *this; +#if BOOST_CB_ENABLE_DEBUG + debug_iterator_base::operator =(it); +#endif // #if BOOST_CB_ENABLE_DEBUG + m_buff = it.m_buff; + m_it = it.m_it; + return *this; + } + +// Random access iterator methods + + //! Dereferencing operator. + reference operator * () const { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(m_it != 0); // check for iterator pointing to end() + return *m_it; + } + + //! Dereferencing operator. + pointer operator -> () const { return &(operator*()); } + + //! Difference operator. + template + difference_type operator - (const iterator& it) const { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator + return linearize_pointer(*this) - linearize_pointer(it); + } + + //! Increment operator (prefix). + iterator& operator ++ () { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(m_it != 0); // check for iterator pointing to end() + m_buff->increment(m_it); + if (m_it == m_buff->m_last) + m_it = 0; + return *this; + } + + //! Increment operator (postfix). + iterator operator ++ (int) { + iterator tmp = *this; + ++*this; + return tmp; + } + + //! Decrement operator (prefix). + iterator& operator -- () { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(m_it != m_buff->m_first); // check for iterator pointing to begin() + if (m_it == 0) + m_it = m_buff->m_last; + m_buff->decrement(m_it); + return *this; + } + + //! Decrement operator (postfix). + iterator operator -- (int) { + iterator tmp = *this; + --*this; + return tmp; + } + + //! Iterator addition. + iterator& operator += (difference_type n) { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + if (n > 0) { + BOOST_CB_ASSERT(m_buff->end() - *this >= n); // check for too large n + m_it = m_buff->add(m_it, n); + if (m_it == m_buff->m_last) + m_it = 0; + } else if (n < 0) { + *this -= -n; + } + return *this; + } + + //! Iterator addition. + iterator operator + (difference_type n) const { return iterator(*this) += n; } + + //! Iterator subtraction. + iterator& operator -= (difference_type n) { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + if (n > 0) { + BOOST_CB_ASSERT(*this - m_buff->begin() >= n); // check for too large n + m_it = m_buff->sub(m_it == 0 ? m_buff->m_last : m_it, n); + } else if (n < 0) { + *this += -n; + } + return *this; + } + + //! Iterator subtraction. + iterator operator - (difference_type n) const { return iterator(*this) -= n; } + + //! Element access operator. + reference operator [] (difference_type n) const { return *(*this + n); } + +// Equality & comparison + + //! Equality. + template + bool operator == (const iterator& it) const { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator + return m_it == it.m_it; + } + + //! Inequality. + template + bool operator != (const iterator& it) const { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator + return m_it != it.m_it; + } + + //! Less. + template + bool operator < (const iterator& it) const { + BOOST_CB_ASSERT(is_valid(m_buff)); // check for uninitialized or invalidated iterator + BOOST_CB_ASSERT(it.is_valid(m_buff)); // check for uninitialized or invalidated iterator + return linearize_pointer(*this) < linearize_pointer(it); + } + + //! Greater. + template + bool operator > (const iterator& it) const { return it < *this; } + + //! Less or equal. + template + bool operator <= (const iterator& it) const { return !(it < *this); } + + //! Greater or equal. + template + bool operator >= (const iterator& it) const { return !(*this < it); } + +// Helpers + + //! Get a pointer which would point to the same element as the iterator in case the circular buffer is linearized. + template + typename Traits0::pointer linearize_pointer(const iterator& it) const { + return it.m_it == 0 ? m_buff->m_buff + m_buff->size() : + (it.m_it < m_buff->m_first ? it.m_it + (m_buff->m_end - m_buff->m_first) + : m_buff->m_buff + (it.m_it - m_buff->m_first)); + } +}; + +//! Iterator addition. +template +inline iterator +operator + (typename Traits::difference_type n, const iterator& it) { + return it + n; +} + +/*! + \fn ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest) + \brief Equivalent of std::uninitialized_copy but with explicit specification of value type. +*/ +template +inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) { + ForwardIterator next = dest; + BOOST_TRY { + for (; first != last; ++first, ++dest) + boost::container::allocator_traits::construct(a, boost::addressof(*dest), *first); + } BOOST_CATCH(...) { + for (; next != dest; ++next) + boost::container::allocator_traits::destroy(a, boost::addressof(*next)); + BOOST_RETHROW + } + BOOST_CATCH_END + return dest; +} + +template +ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a, + true_type) { + for (; first != last; ++first, ++dest) + boost::container::allocator_traits::construct(a, boost::addressof(*dest), boost::move(*first)); + return dest; +} + +template +ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a, + false_type) { + return uninitialized_copy(first, last, dest, a); +} + +/*! + \fn ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest) + \brief Equivalent of std::uninitialized_copy but with explicit specification of value type and moves elements if they have noexcept move constructors. +*/ +template +ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) { + typedef typename boost::is_nothrow_move_constructible::value_type>::type tag_t; + return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t()); +} + +/*! + \fn void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const T& item, Alloc& alloc) + \brief Equivalent of std::uninitialized_fill_n with allocator. +*/ +template +inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const T& item, Alloc& alloc) { + ForwardIterator next = first; + BOOST_TRY { + for (; n > 0; ++first, --n) + boost::container::allocator_traits::construct(alloc, boost::addressof(*first), item); + } BOOST_CATCH(...) { + for (; next != first; ++next) + boost::container::allocator_traits::destroy(alloc, boost::addressof(*next)); + BOOST_RETHROW + } + BOOST_CATCH_END +} + +} // namespace cb_details + +} // namespace boost + +#if defined(_MSC_VER) +# pragma warning(pop) +#endif + +#endif // #if !defined(BOOST_CIRCULAR_BUFFER_DETAILS_HPP) diff --git a/libktorrent/miniboost/boost/circular_buffer/space_optimized.hpp b/libktorrent/miniboost/boost/circular_buffer/space_optimized.hpp new file mode 100644 index 00000000..688ab957 --- /dev/null +++ b/libktorrent/miniboost/boost/circular_buffer/space_optimized.hpp @@ -0,0 +1,1719 @@ +// Implementation of the circular buffer adaptor. + +// Copyright (c) 2003-2008 Jan Gaspar +// Copyright (c) 2013 Paul A. Bristow // Doxygen comments changed for new version of documentation. +// Copyright (c) 2013 Antony Polukhin // Move semantics implementation. + +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#if !defined(BOOST_CIRCULAR_BUFFER_SPACE_OPTIMIZED_HPP) +#define BOOST_CIRCULAR_BUFFER_SPACE_OPTIMIZED_HPP + +#if defined(_MSC_VER) + #pragma once +#endif + +#include +#include + +namespace boost { + +/*! + \class circular_buffer_space_optimized + \brief Space optimized circular buffer container adaptor. + T must be a copyable class or must have an noexcept move constructor + and move assignment operator. +*/ +template +class circular_buffer_space_optimized : +/*! \cond */ +#if BOOST_CB_ENABLE_DEBUG +public +#endif +/*! \endcond */ +circular_buffer { +public: +// Typedefs + + typedef typename circular_buffer::value_type value_type; + typedef typename circular_buffer::pointer pointer; + typedef typename circular_buffer::const_pointer const_pointer; + typedef typename circular_buffer::reference reference; + typedef typename circular_buffer::const_reference const_reference; + typedef typename circular_buffer::size_type size_type; + typedef typename circular_buffer::difference_type difference_type; + typedef typename circular_buffer::allocator_type allocator_type; + typedef typename circular_buffer::const_iterator const_iterator; + typedef typename circular_buffer::iterator iterator; + typedef typename circular_buffer::const_reverse_iterator const_reverse_iterator; + typedef typename circular_buffer::reverse_iterator reverse_iterator; + typedef typename circular_buffer::array_range array_range; + typedef typename circular_buffer::const_array_range const_array_range; + typedef typename circular_buffer::param_value_type param_value_type; + typedef typename circular_buffer::rvalue_type rvalue_type; + //typedef typename circular_buffer::return_value_type return_value_type; + +/* 
 is not passed through to html or pdf. So 
 is used in code section below.  Ugly :-(
+Ideally want a link to capacity_control, but this would require include details
+and this would expose all the functions in details.
+There must be a better way of doing this.
+*/
+
+    /*! Capacity controller of the space optimized circular buffer.
+
+    \see capacity_control in details.hpp.
+

+
+class capacity_control

+{

+   size_type m_capacity;  // Available capacity.

+   size_type m_min_capacity; // Minimum capacity.

+public:

+   capacity_control(size_type capacity, size_type min_capacity = 0)

+   : m_capacity(capacity), m_min_capacity(min_capacity)

+     {};

+   size_type %capacity() const { return m_capacity; }

+   size_type min_capacity() const { return m_min_capacity; }

+   operator size_type() const { return m_capacity; }

+};

+
+

+
+
+  
Always
+    capacity >= min_capacity.
+  

+  

+    The capacity() represents the capacity
+    of the circular_buffer_space_optimized and
+    the min_capacity() determines the minimal allocated size of its internal buffer.
+ 

+ 
The converting constructor of the capacity_control allows implicit conversion from
+  size_type-like types which ensures compatibility of creating an instance of the
+  circular_buffer_space_optimized with other STL containers.
+
+  On the other hand the operator %size_type()
+  provides implicit conversion to the size_type which allows to treat the
+  capacity of the circular_buffer_space_optimized the same way as in the
+  circular_buffer.
+

+    */
+    typedef cb_details::capacity_control capacity_type;
+
+// Inherited
+
+    using circular_buffer::get_allocator;
+    using circular_buffer::begin;
+    using circular_buffer::end;
+    using circular_buffer::rbegin;
+    using circular_buffer::rend;
+    using circular_buffer::at;
+    using circular_buffer::front;
+    using circular_buffer::back;
+    using circular_buffer::array_one;
+    using circular_buffer::array_two;
+    using circular_buffer::linearize;
+    using circular_buffer::is_linearized;
+    using circular_buffer::rotate;
+    using circular_buffer::size;
+    using circular_buffer::max_size;
+    using circular_buffer::empty;
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    reference operator [] (size_type n) { return circular_buffer::operator[](n); }
+    const_reference operator [] (size_type n) const { return circular_buffer::operator[](n); }
+#else
+    using circular_buffer::operator[];
+#endif
+
+private:
+// Member variables
+
+    //! The capacity controller of the space optimized circular buffer.
+    capacity_type m_capacity_ctrl;
+
+public:
+// Overridden
+
+    //! Is the circular_buffer_space_optimized full?
+    /*!
+        \return true if the number of elements stored in the circular_buffer_space_optimized
+                equals the capacity of the circular_buffer_space_optimized; false otherwise.
+        \throws Nothing.
+        \par Exception Safety
+             No-throw.
+        \par Iterator Invalidation
+             Does not invalidate any iterators.
+        \par Complexity
+             Constant (in the size of the circular_buffer_space_optimized).
+        \sa empty()
+    */
+    bool full() const BOOST_NOEXCEPT { return m_capacity_ctrl == size(); }
+
+    /*! \brief Get the maximum number of elements which can be inserted into the
+               circular_buffer_space_optimized without overwriting any of already stored elements.
+        \return capacity().%capacity() - size()
+        \throws Nothing.
+        \par Exception Safety
+             No-throw.
+        \par Iterator Invalidation
+             Does not invalidate any iterators.
+        \par Complexity
+             Constant (in the size of the circular_buffer_space_optimized).
+        \sa capacity(), size(), max_size()
+    */
+    size_type reserve() const BOOST_NOEXCEPT { return m_capacity_ctrl - size(); }
+
+    //! Get the capacity of the circular_buffer_space_optimized.
+    /*!
+        \return The capacity controller representing the maximum number of elements which can be stored in the
+                circular_buffer_space_optimized and the minimal allocated size of the internal buffer.
+        \throws Nothing.
+        \par Exception Safety
+             No-throw.
+        \par Iterator Invalidation
+             Does not invalidate any iterators.
+        \par Complexity
+             Constant (in the size of the circular_buffer_space_optimized).
+        \sa reserve(), size(), max_size(),
+            set_capacity(const capacity_type&)
+    */
+    const capacity_type& capacity() const BOOST_NOEXCEPT { return m_capacity_ctrl; }
+
+#if defined(BOOST_CB_TEST)
+
+    // Return the current capacity of the adapted circular buffer.
+    /*
+       \note This method is not intended to be used directly by the user.
+             It is defined only for testing purposes.
+    */
+    size_type internal_capacity() const BOOST_NOEXCEPT { return circular_buffer::capacity(); }
+
+#endif // #if defined(BOOST_CB_TEST)
+
+    /*! \brief Change the capacity (and the minimal guaranteed amount of allocated memory) of the
+               circular_buffer_space_optimized.
+        \post capacity() == capacity_ctrl \&\& size() \<= capacity_ctrl.capacity()


+              If the current number of elements stored in the circular_buffer_space_optimized is greater
+              than the desired new capacity then number of [size() - capacity_ctrl.capacity()] last
+              elements will be removed and the new size will be equal to capacity_ctrl.capacity().


+              If the current number of elements stored in the circular_buffer_space_optimized is lower
+              than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as
+              necessary but it will never drop below capacity_ctrl.min_capacity().
+        \param capacity_ctrl The new capacity controller.
+        \throws "An allocation error" if memory is exhausted, (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Strong.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in min[size(), capacity_ctrl.%capacity()]).
+        \note To explicitly clear the extra allocated memory use the shrink-to-fit technique:


+              %boost::%circular_buffer_space_optimized\ cb(1000);

+              ...

+              %boost::%circular_buffer_space_optimized\(cb).swap(cb);


+              For more information about the shrink-to-fit technique in STL see
+              http://www.gotw.ca/gotw/054.htm.
+        \sa rset_capacity(const capacity_type&),
+            \link resize() resize(size_type, const_reference)\endlink
+    */
+    void set_capacity(const capacity_type& capacity_ctrl) {
+        m_capacity_ctrl = capacity_ctrl;
+        if (capacity_ctrl < size()) {
+            iterator e = end();
+            circular_buffer::erase(e - (size() - capacity_ctrl), e);
+        }
+        adjust_min_capacity();
+    }
+
+    //! Change the size of the circular_buffer_space_optimized.
+    /*!
+        \post size() == new_size \&\& capacity().%capacity() >= new_size


+              If the new size is greater than the current size, copies of item will be inserted at the
+              back of the of the circular_buffer_space_optimized in order to achieve the desired
+              size. In the case the resulting size exceeds the current capacity the capacity will be set to
+              new_size.


+              If the current number of elements stored in the circular_buffer_space_optimized is greater
+              than the desired new size then number of [size() - new_size] last elements will be
+              removed. (The capacity will remain unchanged.)


+              The amount of allocated memory in the internal buffer may be accommodated as necessary.
+        \param new_size The new size.
+        \param item The element the circular_buffer_space_optimized will be filled with in order to gain
+                    the requested size. (See the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the new size of the circular_buffer_space_optimized).
+        \sa \link rresize() rresize(size_type, const_reference)\endlink,
+            set_capacity(const capacity_type&)
+    */
+    void resize(size_type new_size, param_value_type item = value_type()) {
+        if (new_size > size()) {
+            if (new_size > m_capacity_ctrl)
+                m_capacity_ctrl = capacity_type(new_size, m_capacity_ctrl.min_capacity());
+            insert(end(), new_size - size(), item);
+        } else {
+            iterator e = end();
+            erase(e - (size() - new_size), e);
+        }
+    }
+
+    /*! \brief Change the capacity (and the minimal guaranteed amount of allocated memory) of the
+               circular_buffer_space_optimized.
+        \post capacity() == capacity_ctrl \&\& size() \<= capacity_ctrl


+              If the current number of elements stored in the circular_buffer_space_optimized is greater
+              than the desired new capacity then number of [size() - capacity_ctrl.capacity()]
+              first elements will be removed and the new size will be equal to
+              capacity_ctrl.capacity().


+              If the current number of elements stored in the circular_buffer_space_optimized is lower
+              than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as
+              necessary but it will never drop below capacity_ctrl.min_capacity().
+        \param capacity_ctrl The new capacity controller.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Strong.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in min[size(), capacity_ctrl.%capacity()]).
+        \sa set_capacity(const capacity_type&),
+            \link rresize() rresize(size_type, const_reference)\endlink
+    */
+    void rset_capacity(const capacity_type& capacity_ctrl) {
+        m_capacity_ctrl = capacity_ctrl;
+        if (capacity_ctrl < size()) {
+            iterator b = begin();
+            circular_buffer::rerase(b, b + (size() - capacity_ctrl));
+        }
+        adjust_min_capacity();
+    }
+
+    //! Change the size of the circular_buffer_space_optimized.
+    /*!
+        \post size() == new_size \&\& capacity().%capacity() >= new_size


+              If the new size is greater than the current size, copies of item will be inserted at the
+              front of the of the circular_buffer_space_optimized in order to achieve the desired
+              size. In the case the resulting size exceeds the current capacity the capacity will be set to
+              new_size.


+              If the current number of elements stored in the circular_buffer_space_optimized is greater
+              than the desired new size then number of [size() - new_size] first elements will be
+              removed. (The capacity will remain unchanged.)


+              The amount of allocated memory in the internal buffer may be accommodated as necessary.
+        \param new_size The new size.
+        \param item The element the circular_buffer_space_optimized will be filled with in order to gain
+                    the requested size. (See the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the new size of the circular_buffer_space_optimized).
+        \sa \link resize() resize(size_type, const_reference)\endlink,
+            rset_capacity(const capacity_type&)
+    */
+    void rresize(size_type new_size, param_value_type item = value_type()) {
+        if (new_size > size()) {
+            if (new_size > m_capacity_ctrl)
+                m_capacity_ctrl = capacity_type(new_size, m_capacity_ctrl.min_capacity());
+            rinsert(begin(), new_size - size(), item);
+        } else {
+            rerase(begin(), end() - new_size);
+        }
+    }
+
+    //! Create an empty space optimized circular buffer with zero capacity.
+    /*!
+        \post capacity().%capacity() == 0 \&\& capacity().min_capacity() == 0 \&\& size() == 0
+        \param alloc The allocator.
+        \throws Nothing.
+        \par Complexity
+             Constant.
+        \warning Since Boost version 1.36 the behaviour of this constructor has changed. Now it creates a space
+                 optimized circular buffer with zero capacity.
+    */
+    explicit circular_buffer_space_optimized(const allocator_type& alloc = allocator_type()) BOOST_NOEXCEPT
+    : circular_buffer(0, alloc)
+    , m_capacity_ctrl(0) {}
+
+    //! Create an empty space optimized circular buffer with the specified capacity.
+    /*!
+        \post capacity() == capacity_ctrl \&\& size() == 0


+              The amount of allocated memory in the internal buffer is capacity_ctrl.min_capacity().
+        \param capacity_ctrl The capacity controller representing the maximum number of elements which can be stored in
+                             the circular_buffer_space_optimized and the minimal allocated size of the
+                             internal buffer.
+        \param alloc The allocator.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \par Complexity
+             Constant.
+    */
+    explicit circular_buffer_space_optimized(capacity_type capacity_ctrl,
+        const allocator_type& alloc = allocator_type())
+    : circular_buffer(capacity_ctrl.min_capacity(), alloc)
+    , m_capacity_ctrl(capacity_ctrl) {}
+
+    /*! \brief Create a full space optimized circular buffer with the specified capacity filled with
+               capacity_ctrl.%capacity() copies of item.
+        \post capacity() == capacity_ctrl \&\& full() \&\& (*this)[0] == item \&\& (*this)[1] == item \&\& ...
+              \&\& (*this) [capacity_ctrl.%capacity() - 1] == item 


+              The amount of allocated memory in the internal buffer is capacity_ctrl.capacity().
+        \param capacity_ctrl The capacity controller representing the maximum number of elements which can be stored in
+                             the circular_buffer_space_optimized and the minimal allocated size of the
+                             internal buffer.
+        \param item The element the created circular_buffer_space_optimized will be filled with.
+        \param alloc The allocator.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \throws Whatever T::T(const T&) throws.
+        \par Complexity
+             Linear (in the capacity_ctrl.%capacity()).
+    */
+    circular_buffer_space_optimized(capacity_type capacity_ctrl, param_value_type item,
+        const allocator_type& alloc = allocator_type())
+    : circular_buffer(capacity_ctrl.capacity(), item, alloc)
+    , m_capacity_ctrl(capacity_ctrl) {}
+
+    /*! \brief Create a space optimized circular buffer with the specified capacity filled with n copies
+               of item.
+        \pre capacity_ctrl.%capacity() >= n
+        \post capacity() == capacity_ctrl \&\& size() == n \&\& (*this)[0] == item \&\& (*this)[1] == item
+              \&\& ... \&\& (*this)[n - 1] == item


+              The amount of allocated memory in the internal buffer is
+              max[n, capacity_ctrl.min_capacity()].
+        \param capacity_ctrl The capacity controller representing the maximum number of elements which can be stored in
+                             the circular_buffer_space_optimized and the minimal allocated size of the
+                             internal buffer.
+        \param n The number of elements the created circular_buffer_space_optimized will be filled with.
+        \param item The element the created circular_buffer_space_optimized will be filled with.
+        \param alloc The allocator.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Complexity
+             Linear (in the n).
+    */
+    circular_buffer_space_optimized(capacity_type capacity_ctrl, size_type n, param_value_type item,
+        const allocator_type& alloc = allocator_type())
+    : circular_buffer(init_capacity(capacity_ctrl, n), n, item, alloc)
+    , m_capacity_ctrl(capacity_ctrl) {}
+
+    //! The copy constructor.
+    /*!
+        Creates a copy of the specified circular_buffer_space_optimized.
+        \post *this == cb


+              The amount of allocated memory in the internal buffer is cb.size().
+        \param cb The circular_buffer_space_optimized to be copied.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Complexity
+             Linear (in the size of cb).
+    */
+    circular_buffer_space_optimized(const circular_buffer_space_optimized& cb)
+    : circular_buffer(cb.begin(), cb.end(), cb.get_allocator())
+    , m_capacity_ctrl(cb.m_capacity_ctrl) {}
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    //! The move constructor.
+    /*! \brief Move constructs a circular_buffer_space_optimized from cb, 
+                leaving cb empty.
+        \pre C++ compiler with rvalue references support.
+        \post cb.empty()
+        \param cb circular_buffer to 'steal' value from.
+        \throws Nothing.
+        \par Constant.
+    */
+    circular_buffer_space_optimized(circular_buffer_space_optimized&& cb) BOOST_NOEXCEPT
+    : circular_buffer()
+    , m_capacity_ctrl(0) {
+        cb.swap(*this);
+    }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    //! Create a full space optimized circular buffer filled with a copy of the range.
+    /*!
+        \pre Valid range [first, last).

+             first and last have to meet the requirements of
+             InputIterator.
+        \post capacity().%capacity() == std::distance(first, last) \&\& capacity().min_capacity() == 0 \&\&
+              full() \&\& (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ... \&\&
+              (*this)[std::distance(first, last) - 1] == *(last - 1)


+              The amount of allocated memory in the internal buffer is std::distance(first, last).
+        \param first The beginning of the range to be copied.
+        \param last The end of the range to be copied.
+        \param alloc The allocator.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept 
+                and InputIterator is a move iterator.
+        \par Complexity
+             Linear (in the std::distance(first, last)).
+    */
+    template 
+    circular_buffer_space_optimized(InputIterator first, InputIterator last,
+        const allocator_type& alloc = allocator_type())
+    : circular_buffer(first, last, alloc)
+    , m_capacity_ctrl(circular_buffer::capacity()) {}
+
+    /*! \brief Create a space optimized circular buffer with the specified capacity (and the minimal guaranteed amount
+               of allocated memory) filled with a copy of the range.
+        \pre Valid range [first, last).

+             first and last have to meet the requirements of
+             InputIterator.
+        \post capacity() == capacity_ctrl \&\& size() \<= std::distance(first, last) \&\& (*this)[0]==
+              *(last - capacity_ctrl.%capacity()) \&\& (*this)[1] == *(last - capacity_ctrl.%capacity() + 1) \&\& ...
+              \&\& (*this)[capacity_ctrl.%capacity() - 1] == *(last - 1)


+              If the number of items to be copied from the range [first, last) is greater than the
+              specified capacity_ctrl.%capacity() then only elements from the range
+              [last - capacity_ctrl.%capacity(), last) will be copied.


+              The amount of allocated memory in the internal buffer is max[capacity_ctrl.min_capacity(),
+              min[capacity_ctrl.%capacity(), std::distance(first, last)]].
+        \param capacity_ctrl The capacity controller representing the maximum number of elements which can be stored in
+                             the circular_buffer_space_optimized and the minimal allocated size of the
+                             internal buffer.
+        \param first The beginning of the range to be copied.
+        \param last The end of the range to be copied.
+        \param alloc The allocator.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Complexity
+             Linear (in std::distance(first, last); in
+             min[capacity_ctrl.%capacity(), std::distance(first, last)] if the InputIterator
+             is a RandomAccessIterator).
+    */
+    template 
+    circular_buffer_space_optimized(capacity_type capacity_ctrl, InputIterator first, InputIterator last,
+        const allocator_type& alloc = allocator_type())
+    : circular_buffer(
+        init_capacity(capacity_ctrl, first, last, is_integral()),
+        first, last, alloc)
+    , m_capacity_ctrl(capacity_ctrl) {
+        reduce_capacity(
+            is_same< BOOST_DEDUCED_TYPENAME iterator_category::type, std::input_iterator_tag >());
+    }
+
+#if defined(BOOST_CB_NEVER_DEFINED)
+// This section will never be compiled - the default destructor will be generated instead.
+// Declared only for documentation purpose.
+
+    //! The destructor.
+    /*!
+        Destroys the circular_buffer_space_optimized.
+        \throws Nothing.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (including
+             iterators equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa clear()
+    */
+    ~circular_buffer_space_optimized();
+
+    //! no-comment
+    void erase_begin(size_type n);
+
+    //! no-comment
+    void erase_end(size_type n);
+
+#endif // #if defined(BOOST_CB_NEVER_DEFINED)
+
+    //! The assign operator.
+    /*!
+        Makes this circular_buffer_space_optimized to become a copy of the specified
+        circular_buffer_space_optimized.
+        \post *this == cb


+              The amount of allocated memory in the internal buffer is cb.size().
+        \param cb The circular_buffer_space_optimized to be copied.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \throws Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Strong.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to this circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of cb).
+        \sa \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink,
+            \link assign(capacity_type, size_type, param_value_type)
+            assign(capacity_type, size_type, const_reference)\endlink,
+            assign(InputIterator, InputIterator),
+            assign(capacity_type, InputIterator, InputIterator)
+    */
+    circular_buffer_space_optimized& operator = (const circular_buffer_space_optimized& cb) {
+        if (this == &cb)
+            return *this;
+        circular_buffer::assign(cb.begin(), cb.end());
+        m_capacity_ctrl = cb.m_capacity_ctrl;
+        return *this;
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    /*! \brief Move assigns content of cb to *this, leaving cb empty.
+        \pre C++ compiler with rvalue references support.
+        \post cb.empty()
+        \param cb circular_buffer to 'steal' value from.
+        \throws Nothing.
+        \par Complexity
+             Constant.
+    */
+    circular_buffer_space_optimized& operator = (circular_buffer_space_optimized&& cb) BOOST_NOEXCEPT {
+        cb.swap(*this); // now `this` holds `cb`
+        circular_buffer(get_allocator()) // temprary that holds initial `cb` allocator
+            .swap(cb); // makes `cb` empty
+        return *this;
+    }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+
+    //! Assign n items into the space optimized circular buffer.
+    /*!
+        The content of the circular_buffer_space_optimized will be removed and replaced with
+        n copies of the item.
+        \post capacity().%capacity() == n \&\& capacity().min_capacity() == 0 \&\& size() == n \&\& (*this)[0] ==
+              item \&\& (*this)[1] == item \&\& ... \&\& (*this) [n - 1] == item


+              The amount of allocated memory in the internal buffer is n.
+        \param n The number of elements the circular_buffer_space_optimized will be filled with.
+        \param item The element the circular_buffer_space_optimized will be filled with.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the n).
+        \sa \link operator=(const circular_buffer_space_optimized&) operator=\endlink,
+            \link assign(capacity_type, size_type, param_value_type)
+            assign(capacity_type, size_type, const_reference)\endlink,
+            assign(InputIterator, InputIterator),
+            assign(capacity_type, InputIterator, InputIterator)
+    */
+    void assign(size_type n, param_value_type item) {
+        circular_buffer::assign(n, item);
+        m_capacity_ctrl = capacity_type(n);
+    }
+
+    //! Assign n items into the space optimized circular buffer specifying the capacity.
+    /*!
+        The capacity of the circular_buffer_space_optimized will be set to the specified value and the
+        content of the circular_buffer_space_optimized will be removed and replaced with n
+        copies of the item.
+        \pre capacity_ctrl.%capacity() >= n
+        \post capacity() == capacity_ctrl \&\& size() == n \&\& (*this)[0] == item \&\& (*this)[1] == item
+              \&\& ... \&\& (*this) [n - 1] == item 


+              The amount of allocated memory will be max[n, capacity_ctrl.min_capacity()].
+        \param capacity_ctrl The new capacity controller.
+        \param n The number of elements the circular_buffer_space_optimized will be filled with.
+        \param item The element the circular_buffer_space_optimized will be filled with.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the n).
+        \sa \link operator=(const circular_buffer_space_optimized&) operator=\endlink,
+            \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink,
+            assign(InputIterator, InputIterator),
+            assign(capacity_type, InputIterator, InputIterator)
+    */
+    void assign(capacity_type capacity_ctrl, size_type n, param_value_type item) {
+       BOOST_CB_ASSERT(capacity_ctrl.capacity() >= n); // check for new capacity lower than n
+       circular_buffer::assign((std::max)(capacity_ctrl.min_capacity(), n), n, item);
+       m_capacity_ctrl = capacity_ctrl;
+    }
+
+    //! Assign a copy of the range into the space optimized circular buffer.
+    /*!
+        The content of the circular_buffer_space_optimized will be removed and replaced with copies of
+        elements from the specified range.
+        \pre Valid range [first, last).

+             first and last have to meet the requirements of
+             InputIterator.
+        \post capacity().%capacity() == std::distance(first, last) \&\& capacity().min_capacity() == 0 \&\&
+              size() == std::distance(first, last) \&\& (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ...
+              \&\& (*this)[std::distance(first, last) - 1] == *(last - 1)


+              The amount of allocated memory in the internal buffer is std::distance(first, last).
+        \param first The beginning of the range to be copied.
+        \param last The end of the range to be copied.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept and 
+                InputIterator is a move iterator.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the std::distance(first, last)).
+        \sa \link operator=(const circular_buffer_space_optimized&) operator=\endlink,
+            \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink,
+            \link assign(capacity_type, size_type, param_value_type)
+            assign(capacity_type, size_type, const_reference)\endlink,
+            assign(capacity_type, InputIterator, InputIterator)
+    */
+    template 
+    void assign(InputIterator first, InputIterator last) {
+        circular_buffer::assign(first, last);
+        m_capacity_ctrl = capacity_type(circular_buffer::capacity());
+    }
+
+    //! Assign a copy of the range into the space optimized circular buffer specifying the capacity.
+    /*!
+        The capacity of the circular_buffer_space_optimized will be set to the specified value and the
+        content of the circular_buffer_space_optimized will be removed and replaced with copies of
+        elements from the specified range.
+        \pre Valid range [first, last).

+             first and last have to meet the requirements of
+             InputIterator.
+        \post capacity() == capacity_ctrl \&\& size() \<= std::distance(first, last) \&\&
+             (*this)[0]== *(last - capacity) \&\& (*this)[1] == *(last - capacity + 1) \&\& ... \&\&
+             (*this)[capacity - 1] == *(last - 1)


+             If the number of items to be copied from the range [first, last) is greater than the
+             specified capacity then only elements from the range [last - capacity, last)
+             will be copied.

 The amount of allocated memory in the internal buffer is
+             max[std::distance(first, last), capacity_ctrl.min_capacity()].
+        \param capacity_ctrl The new capacity controller.
+        \param first The beginning of the range to be copied.
+        \param last The end of the range to be copied.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept and 
+                InputIterator is a move iterator.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in std::distance(first, last); in
+             min[capacity_ctrl.%capacity(), std::distance(first, last)] if the InputIterator
+             is a RandomAccessIterator).
+        \sa \link operator=(const circular_buffer_space_optimized&) operator=\endlink,
+            \link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink,
+            \link assign(capacity_type, size_type, param_value_type)
+            assign(capacity_type, size_type, const_reference)\endlink,
+            assign(InputIterator, InputIterator)
+    */
+    template 
+    void assign(capacity_type capacity_ctrl, InputIterator first, InputIterator last) {
+       m_capacity_ctrl = capacity_ctrl;
+       circular_buffer::assign(capacity_ctrl, first, last);
+    }
+
+    //! Swap the contents of two space-optimized circular-buffers.
+    /*!
+        \post this contains elements of cb and vice versa; the capacity and the amount of
+              allocated memory in the internal buffer of this equal to the capacity and the amount of
+              allocated memory of cb and vice versa.
+        \param cb The circular_buffer_space_optimized whose content will be swapped.
+        \throws Nothing.
+        \par Exception Safety
+             No-throw.
+        \par Iterator Invalidation
+             Invalidates all iterators of both circular_buffer_space_optimized containers. (On the other
+             hand the iterators still point to the same elements but within another container. If you want to rely on
+             this feature you have to turn the __debug_support off by defining macro BOOST_CB_DISABLE_DEBUG,
+             otherwise an assertion will report an error if such invalidated iterator is used.)
+        \par Complexity
+             Constant (in the size of the circular_buffer_space_optimized).
+        \sa swap(circular_buffer&, circular_buffer&), 
+            swap(circular_buffer_space_optimized&, circular_buffer_space_optimized&)
+
+
+    */
+    // Note link does not work right.  Asked on Doxygen forum for advice 23 May 2103.
+
+    void swap(circular_buffer_space_optimized& cb) BOOST_NOEXCEPT {
+        std::swap(m_capacity_ctrl, cb.m_capacity_ctrl);
+        circular_buffer::swap(cb);
+    }
+
+    //! Insert a new element at the end of the space optimized circular buffer.
+    /*!
+        \post if capacity().%capacity() > 0 then back() == item

+              If the circular_buffer_space_optimized is full, the first element will be removed. If the
+              capacity is 0, nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param item The element to be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link push_front() push_front(const_reference)\endlink, pop_back(),
+            pop_front()
+    */
+    void push_back(param_value_type item) {
+        check_low_capacity();
+        circular_buffer::push_back(item);
+    }
+
+    //! Insert a new element at the end of the space optimized circular buffer.
+    /*!
+        \post if capacity().%capacity() > 0 then back() == item

+              If the circular_buffer_space_optimized is full, the first element will be removed. If the
+              capacity is 0, nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param item The element to be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link push_front() push_front(const_reference)\endlink, pop_back(),
+            pop_front()
+    */
+    void push_back(rvalue_type item) {
+        check_low_capacity();
+        circular_buffer::push_back(boost::move(item));
+    }
+
+    //! Insert a new element at the end of the space optimized circular buffer.
+    /*!
+        \post if capacity().%capacity() > 0 then back() == item

+              If the circular_buffer_space_optimized is full, the first element will be removed. If the
+              capacity is 0, nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T() throws. 
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link push_front() push_front(const_reference)\endlink, pop_back(),
+            pop_front()
+    */
+    void push_back() {
+        check_low_capacity();
+        circular_buffer::push_back();
+    }
+
+    //! Insert a new element at the beginning of the space optimized circular buffer.
+    /*!
+        \post if capacity().%capacity() > 0 then front() == item

+              If the circular_buffer_space_optimized is full, the last element will be removed. If the
+              capacity is 0, nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param item The element to be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link push_back() push_back(const_reference)\endlink, pop_back(),
+            pop_front()
+    */
+    void push_front(param_value_type item) {
+        check_low_capacity();
+        circular_buffer::push_front(item);
+    }
+
+    //! Insert a new element at the beginning of the space optimized circular buffer.
+    /*!
+        \post if capacity().%capacity() > 0 then front() == item

+              If the circular_buffer_space_optimized is full, the last element will be removed. If the
+              capacity is 0, nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param item The element to be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link push_back() push_back(const_reference)\endlink, pop_back(),
+            pop_front()
+    */
+    void push_front(rvalue_type item) {
+        check_low_capacity();
+        circular_buffer::push_front(boost::move(item));
+    }
+
+    //! Insert a new element at the beginning of the space optimized circular buffer.
+    /*!
+        \post if capacity().%capacity() > 0 then front() == item

+              If the circular_buffer_space_optimized is full, the last element will be removed. If the
+              capacity is 0, nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T() throws.
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link push_back() push_back(const_reference)\endlink, pop_back(),
+            pop_front()
+    */
+    void push_front() {
+        check_low_capacity();
+        circular_buffer::push_front();
+    }
+
+    //! Remove the last element from the space optimized circular buffer.
+    /*!
+        \pre !empty()
+        \post The last element is removed from the circular_buffer_space_optimized.


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa pop_front(), \link push_back() push_back(const_reference)\endlink,
+            \link push_front() push_front(const_reference)\endlink
+    */
+    void pop_back() {
+        circular_buffer::pop_back();
+        check_high_capacity();
+    }
+
+    //! Remove the first element from the space optimized circular buffer.
+    /*!
+        \pre !empty()
+        \post The first element is removed from the circular_buffer_space_optimized.


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa pop_back(), \link push_back() push_back(const_reference)\endlink,
+            \link push_front() push_front(const_reference)\endlink
+    */
+    void pop_front() {
+        circular_buffer::pop_front();
+        check_high_capacity();
+    }
+
+    //! Insert an element at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The item will be inserted at the position pos.

+              If the circular_buffer_space_optimized is full, the first element will be overwritten. If
+              the circular_buffer_space_optimized is full and the pos points to
+              begin(), then the item will not be inserted. If the capacity is 0,
+              nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the item will be inserted.
+        \param item The element to be inserted.
+        \return Iterator to the inserted element or begin() if the item is not inserted. (See
+                the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+                Whatever T::operator = (const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator),
+            \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink,
+            \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator)
+    */
+    iterator insert(iterator pos, param_value_type item) {
+        size_type index = pos - begin();
+        check_low_capacity();
+        return circular_buffer::insert(begin() + index, item);
+    }
+
+    //! Insert an element at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The item will be inserted at the position pos.

+              If the circular_buffer_space_optimized is full, the first element will be overwritten. If
+              the circular_buffer_space_optimized is full and the pos points to
+              begin(), then the item will not be inserted. If the capacity is 0,
+              nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the item will be inserted.
+        \param item The element to be inserted.
+        \return Iterator to the inserted element or begin() if the item is not inserted. (See
+                the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator),
+            \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink,
+            \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator)
+    */
+    iterator insert(iterator pos, rvalue_type item) {
+        size_type index = pos - begin();
+        check_low_capacity();
+        return circular_buffer::insert(begin() + index, boost::move(item));
+    }
+
+    //! Insert an element at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The item will be inserted at the position pos.

+              If the circular_buffer_space_optimized is full, the first element will be overwritten. If
+              the circular_buffer_space_optimized is full and the pos points to
+              begin(), then the item will not be inserted. If the capacity is 0,
+              nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the item will be inserted.
+        \return Iterator to the inserted element or begin() if the item is not inserted. (See
+                the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T() throws.
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator),
+            \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink,
+            \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator)
+    */
+    iterator insert(iterator pos) {
+        size_type index = pos - begin();
+        check_low_capacity();
+        return circular_buffer::insert(begin() + index);
+    }
+
+    //! Insert n copies of the item at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The number of min[n, (pos - begin()) + reserve()] elements will be inserted at the position
+              pos.
The number of min[pos - begin(), max[0, n - reserve()]] elements will
+              be overwritten at the beginning of the circular_buffer_space_optimized.
(See
+              Example for the explanation.)


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the items will be inserted.
+        \param n The number of items the to be inserted.
+        \param item The element whose copies will be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+                Whatever T::operator = (const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in min[capacity().%capacity(), size() + n]).
+        \par Example
+             Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its
+             internal buffer may look like the one below.


+             |1|2|3|4| | |

+             p ___^

After inserting 5 elements at the position p:


+             insert(p, (size_t)5, 0);

actually only 4 elements get inserted and elements
+             1 and 2 are overwritten. This is due to the fact the insert operation preserves
+             the capacity. After insertion the internal buffer looks like this:

|0|0|0|0|3|4|

+             
For comparison if the capacity would not be preserved the internal buffer would then result in
+             |1|2|0|0|0|0|0|3|4|.
+        \sa \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator),
+            \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink,
+            \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator)
+    */
+    void insert(iterator pos, size_type n, param_value_type item) {
+        size_type index = pos - begin();
+        check_low_capacity(n);
+        circular_buffer::insert(begin() + index, n, item);
+    }
+
+    //! Insert the range [first, last) at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
Valid range [first, last) where first and last meet the
+             requirements of an InputIterator.
+        \post Elements from the range
+              [first + max[0, distance(first, last) - (pos - begin()) - reserve()], last) will be
+              inserted at the position pos.
The number of min[pos - begin(), max[0,
+              distance(first, last) - reserve()]] elements will be overwritten at the beginning of the
+              circular_buffer_space_optimized.
(See Example for the explanation.)


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the range will be inserted.
+        \param first The beginning of the range to be inserted.
+        \param last The end of the range to be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in [size() + std::distance(first, last)]; in
+             min[capacity().%capacity(), size() + std::distance(first, last)] if the
+             InputIterator is a
+             RandomAccessIterator).
+        \par Example
+             Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its
+             internal buffer may look like the one below.


+             |1|2|3|4| | |

+             p ___^

After inserting a range of elements at the position p:


+             int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);


+             actually only elements 6, 7, 8 and 9 from the
+             specified range get inserted and elements 1 and 2 are overwritten. This is due
+             to the fact the insert operation preserves the capacity. After insertion the internal buffer looks like
+             this:

|6|7|8|9|3|4|

For comparison if the capacity would not be preserved the
+             internal buffer would then result in |1|2|5|6|7|8|9|3|4|.
+        \sa \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink,
+            \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink, \link rinsert(iterator, param_value_type)
+            rinsert(iterator, value_type)\endlink, \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator)
+    */
+    template 
+    void insert(iterator pos, InputIterator first, InputIterator last) {
+        insert(pos, first, last, is_integral());
+    }
+
+    //! Insert an element before the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The item will be inserted before the position pos.

+              If the circular_buffer_space_optimized is full, the last element will be overwritten. If the
+              circular_buffer_space_optimized is full and the pos points to
+              end(), then the item will not be inserted. If the capacity is 0,
+              nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position before which the item will be inserted.
+        \param item The element to be inserted.
+        \return Iterator to the inserted element or end() if the item is not inserted. (See
+                the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+                Whatever T::operator = (const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator),
+            \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink,
+            \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator)
+    */
+    iterator rinsert(iterator pos, param_value_type item) {
+        size_type index = pos - begin();
+        check_low_capacity();
+        return circular_buffer::rinsert(begin() + index, item);
+    }
+
+    //! Insert an element before the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The item will be inserted before the position pos.

+              If the circular_buffer_space_optimized is full, the last element will be overwritten. If the
+              circular_buffer_space_optimized is full and the pos points to
+              end(), then the item will not be inserted. If the capacity is 0,
+              nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position before which the item will be inserted.
+        \param item The element to be inserted.
+        \return Iterator to the inserted element or end() if the item is not inserted. (See
+                the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator),
+            \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink,
+            \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator)
+    */
+    iterator rinsert(iterator pos, rvalue_type item) {
+        size_type index = pos - begin();
+        check_low_capacity();
+        return circular_buffer::rinsert(begin() + index, boost::move(item));
+    }
+
+    //! Insert an element before the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The item will be inserted before the position pos.

+              If the circular_buffer_space_optimized is full, the last element will be overwritten. If the
+              circular_buffer_space_optimized is full and the pos points to
+              end(), then the item will not be inserted. If the capacity is 0,
+              nothing will be inserted.


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position before which the item will be inserted.
+        \return Iterator to the inserted element or end() if the item is not inserted. (See
+                the Effect.)
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T() throws.
+                Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator),
+            \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink,
+            \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator)
+    */
+    iterator rinsert(iterator pos) {
+        size_type index = pos - begin();
+        check_low_capacity();
+        return circular_buffer::rinsert(begin() + index);
+    }
+
+    //! Insert n copies of the item before the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.
+        \post The number of min[n, (end() - pos) + reserve()] elements will be inserted before the
+              position pos.
The number of min[end() - pos, max[0, n - reserve()]] elements
+              will be overwritten at the end of the circular_buffer_space_optimized.
(See
+              Example for the explanation.)


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the items will be inserted.
+        \param n The number of items the to be inserted.
+        \param item The element whose copies will be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+                Whatever T::operator = (const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in min[capacity().%capacity(), size() + n]).
+        \par Example
+             Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its
+             internal buffer may look like the one below.


+             |1|2|3|4| | |

+             p ___^

After inserting 5 elements before the position p:


+             rinsert(p, (size_t)5, 0);

actually only 4 elements get inserted and elements
+             3 and 4 are overwritten. This is due to the fact the rinsert operation preserves
+             the capacity. After insertion the internal buffer looks like this:

|1|2|0|0|0|0|

+             
For comparison if the capacity would not be preserved the internal buffer would then result in
+             |1|2|0|0|0|0|0|3|4|.
+        \sa \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink,
+            rinsert(iterator, InputIterator, InputIterator),
+            \link insert(iterator, param_value_type) insert(iterator, value_type)\endlink,
+            \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator)
+    */
+    void rinsert(iterator pos, size_type n, param_value_type item) {
+        size_type index = pos - begin();
+        check_low_capacity(n);
+        circular_buffer::rinsert(begin() + index, n, item);
+    }
+
+        //! Insert the range [first, last) before the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized or its
+             end.

+             Valid range [first, last) where first and last meet the
+             requirements of an InputIterator.
+        \post Elements from the range
+              [first, last - max[0, distance(first, last) - (end() - pos) - reserve()]) will be inserted
+              before the position pos.
The number of min[end() - pos, max[0,
+              distance(first, last) - reserve()]] elements will be overwritten at the end of the
+              circular_buffer.
(See Example for the explanation.)


+              The amount of allocated memory in the internal buffer may be predictively increased.
+        \param pos An iterator specifying the position where the range will be inserted.
+        \param first The beginning of the range to be inserted.
+        \param last The end of the range to be inserted.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::T(const T&) throws.
+                Whatever T::operator = (const T&) throws.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in [size() + std::distance(first, last)]; in
+             min[capacity().%capacity(), size() + std::distance(first, last)] if the
+             InputIterator is a
+             RandomAccessIterator).
+        \par Example
+             Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its
+             internal buffer may look like the one below.


+             |1|2|3|4| | |

+             p ___^

After inserting a range of elements before the position p:


+             int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);


+             actually only elements 5, 6, 7 and 8 from the
+             specified range get inserted and elements 3 and 4 are overwritten. This is due
+             to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks like
+             this:

|1|2|5|6|7|8|

For comparison if the capacity would not be preserved the
+             internal buffer would then result in |1|2|5|6|7|8|9|3|4|.
+        \sa \link rinsert(iterator, param_value_type) rinsert(iterator, value_type)\endlink,
+            \link rinsert(iterator, size_type, param_value_type)
+            rinsert(iterator, size_type, value_type)\endlink, \link insert(iterator, param_value_type)
+            insert(iterator, value_type)\endlink, \link insert(iterator, size_type, param_value_type)
+            insert(iterator, size_type, value_type)\endlink,
+            insert(iterator, InputIterator, InputIterator)
+    */
+    template 
+    void rinsert(iterator pos, InputIterator first, InputIterator last) {
+        rinsert(pos, first, last, is_integral());
+    }
+
+    //! Remove an element at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized (but not
+             an end()).
+        \post The element at the position pos is removed.


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \param pos An iterator pointing at the element to be removed.
+        \return Iterator to the first element remaining beyond the removed element or end() if no such
+                element exists.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::operator = (const T&) throws or 
+                nothing if T::operator = (T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa erase(iterator, iterator), rerase(iterator),
+            rerase(iterator, iterator), clear()
+    */
+    iterator erase(iterator pos) {
+        iterator it = circular_buffer::erase(pos);
+        size_type index = it - begin();
+        check_high_capacity();
+        return begin() + index;
+    }
+
+    //! Erase the range [first, last).
+    /*!
+        \pre Valid range [first, last).
+        \post The elements from the range [first, last) are removed. (If first == last
+              nothing is removed.)


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \param first The beginning of the range to be removed.
+        \param last The end of the range to be removed.
+        \return Iterator to the first element remaining beyond the removed elements or end() if no such
+                element exists.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::operator = (const T&) throws or 
+                nothing if T::operator = (T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa erase(iterator), rerase(iterator), rerase(iterator, iterator),
+            clear()
+    */
+    iterator erase(iterator first, iterator last) {
+        iterator it = circular_buffer::erase(first, last);
+        size_type index = it - begin();
+        check_high_capacity();
+        return begin() + index;
+    }
+
+    //! Remove an element at the specified position.
+    /*!
+        \pre pos is a valid iterator pointing to the circular_buffer_space_optimized (but not
+             an end()).


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \post The element at the position pos is removed.
+        \param pos An iterator pointing at the element to be removed.
+        \return Iterator to the first element remaining in front of the removed element or begin() if no
+                such element exists.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::operator = (const T&) throws or 
+                nothing if T::operator = (T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \note Basically there is no difference between erase(iterator) and this method. It is implemented
+              only for consistency with the base circular_buffer.
+        \sa erase(iterator), erase(iterator, iterator),
+            rerase(iterator, iterator), clear()
+    */
+    iterator rerase(iterator pos) {
+        iterator it = circular_buffer::rerase(pos);
+        size_type index = it - begin();
+        check_high_capacity();
+        return begin() + index;
+    }
+
+    //! Erase the range [first, last).
+    /*!
+        \pre Valid range [first, last).
+        \post The elements from the range [first, last) are removed. (If first == last
+              nothing is removed.)


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \param first The beginning of the range to be removed.
+        \param last The end of the range to be removed.
+        \return Iterator to the first element remaining in front of the removed elements or begin() if no
+                such element exists.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+                Whatever T::operator = (const T&) throws or 
+                nothing if T::operator = (T&&) is noexcept.
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \note Basically there is no difference between erase(iterator, iterator) and this method. It is
+              implemented only for consistency with the base
+              .
+        \sa erase(iterator), erase(iterator, iterator), rerase(iterator),
+            clear()
+    */
+    iterator rerase(iterator first, iterator last) {
+        iterator it = circular_buffer::rerase(first, last);
+        size_type index = it - begin();
+        check_high_capacity();
+        return begin() + index;
+    }
+
+    //! Remove all stored elements from the space optimized circular buffer.
+    /*!
+        \post size() == 0


+              The amount of allocated memory in the internal buffer may be predictively decreased.
+        \throws "An allocation error" if memory is exhausted (std::bad_alloc if the standard allocator is
+                used).
+        \par Exception Safety
+             Basic.
+        \par Iterator Invalidation
+             Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators
+             equal to end()).
+        \par Complexity
+             Linear (in the size of the circular_buffer_space_optimized).
+        \sa ~circular_buffer_space_optimized(), erase(iterator),
+            erase(iterator, iterator), rerase(iterator),
+            rerase(iterator, iterator)
+    */
+    void clear() { erase(begin(), end()); }
+
+private:
+// Helper methods
+
+    //! Adjust the amount of allocated memory.
+    void adjust_min_capacity() {
+        if (m_capacity_ctrl.min_capacity() > circular_buffer::capacity())
+            circular_buffer::set_capacity(m_capacity_ctrl.min_capacity());
+        else
+            check_high_capacity();
+    }
+
+    //! Ensure the reserve for possible growth up.
+    size_type ensure_reserve(size_type new_capacity, size_type buffer_size) const {
+        if (buffer_size + new_capacity / 5 >= new_capacity)
+            new_capacity *= 2; // ensure at least 20% reserve
+        if (new_capacity > m_capacity_ctrl)
+            return m_capacity_ctrl;
+        return new_capacity;
+    }
+
+    //! Check for low capacity.
+    /*
+        \post If the capacity is low it will be increased.
+    */
+    void check_low_capacity(size_type n = 1) {
+        size_type new_size = size() + n;
+        size_type new_capacity = circular_buffer::capacity();
+        if (new_size > new_capacity) {
+            if (new_capacity == 0)
+                new_capacity = 1;
+            for (; new_size > new_capacity; new_capacity *= 2) {}
+            circular_buffer::set_capacity(
+                ensure_reserve(new_capacity, new_size));
+        }
+#if BOOST_CB_ENABLE_DEBUG
+        this->invalidate_iterators_except(end());
+#endif
+    }
+
+    //! Check for high capacity.
+    /*
+        \post If the capacity is high it will be decreased.
+    */
+    void check_high_capacity() {
+        size_type new_capacity = circular_buffer::capacity();
+        while (new_capacity / 3 >= size()) { // (new_capacity / 3) -> avoid oscillations
+            new_capacity /= 2;
+            if (new_capacity <= m_capacity_ctrl.min_capacity()) {
+                new_capacity = m_capacity_ctrl.min_capacity();
+                break;
+            }
+        }
+        circular_buffer::set_capacity(
+            ensure_reserve(new_capacity, size()));
+#if BOOST_CB_ENABLE_DEBUG
+        this->invalidate_iterators_except(end());
+#endif
+    }
+
+    //! Specialized method for reducing the capacity.
+    void reduce_capacity(const true_type&) {
+        circular_buffer::set_capacity((std::max)(m_capacity_ctrl.min_capacity(), size()));
+    }
+
+    //! Specialized method for reducing the capacity.
+    void reduce_capacity(const false_type&) {}
+
+    //! Determine the initial capacity.
+    static size_type init_capacity(const capacity_type& capacity_ctrl, size_type n) {
+        BOOST_CB_ASSERT(capacity_ctrl.capacity() >= n); // check for capacity lower than n
+        return (std::max)(capacity_ctrl.min_capacity(), n);
+    }
+
+    //! Specialized method for determining the initial capacity.
+    template 
+    static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType,
+        const true_type&) {
+        return init_capacity(capacity_ctrl, static_cast(n));
+    }
+
+    //! Specialized method for determining the initial capacity.
+    template 
+    static size_type init_capacity(const capacity_type& capacity_ctrl, Iterator first, Iterator last,
+        const false_type&) {
+        BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+        return init_capacity(capacity_ctrl, first, last, iterator_category::type());
+#else
+        return init_capacity(
+            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME iterator_category::type());
+#endif
+    }
+
+    //! Specialized method for determining the initial capacity.
+    template 
+    static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator, InputIterator,
+        const std::input_iterator_tag&) {
+        return capacity_ctrl.capacity();
+    }
+
+    //! Specialized method for determining the initial capacity.
+    template 
+    static size_type init_capacity(const capacity_type& capacity_ctrl, ForwardIterator first, ForwardIterator last,
+        const std::forward_iterator_tag&) {
+        BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
+        return (std::max)(capacity_ctrl.min_capacity(),
+            (std::min)(capacity_ctrl.capacity(), static_cast(std::distance(first, last))));
+    }
+
+    //! Specialized insert method.
+    template 
+    void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
+        insert(pos, static_cast(n), static_cast(item));
+    }
+
+    //! Specialized insert method.
+    template 
+    void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
+        size_type index = pos - begin();
+        check_low_capacity(std::distance(first, last));
+        circular_buffer::insert(begin() + index, first, last);
+    }
+
+    //! Specialized rinsert method.
+    template 
+    void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
+        rinsert(pos, static_cast(n), static_cast(item));
+    }
+
+    //! Specialized rinsert method.
+    template 
+    void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
+        size_type index = pos - begin();
+        check_low_capacity(std::distance(first, last));
+        circular_buffer::rinsert(begin() + index, first, last);
+    }
+};
+
+// Non-member functions
+
+//! Test two space optimized circular buffers for equality.
+template 
+inline bool operator == (const circular_buffer_space_optimized& lhs,
+    const circular_buffer_space_optimized& rhs) {
+    return lhs.size() == rhs.size() &&
+        std::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+//! Lexicographical comparison.
+template 
+inline bool operator < (const circular_buffer_space_optimized& lhs,
+    const circular_buffer_space_optimized& rhs) {
+    return std::lexicographical_compare(
+        lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+
+//! Test two space optimized circular buffers for non-equality.
+template 
+inline bool operator != (const circular_buffer_space_optimized& lhs,
+    const circular_buffer_space_optimized& rhs) {
+    return !(lhs == rhs);
+}
+
+//! Lexicographical comparison.
+template 
+inline bool operator > (const circular_buffer_space_optimized& lhs,
+    const circular_buffer_space_optimized& rhs) {
+    return rhs < lhs;
+}
+
+//! Lexicographical comparison.
+template 
+inline bool operator <= (const circular_buffer_space_optimized& lhs,
+    const circular_buffer_space_optimized& rhs) {
+    return !(rhs < lhs);
+}
+
+//! Lexicographical comparison.
+template 
+inline bool operator >= (const circular_buffer_space_optimized& lhs,
+    const circular_buffer_space_optimized& rhs) {
+    return !(lhs < rhs);
+}
+
+//! Swap the contents of two space optimized circular buffers.
+template 
+inline void swap(circular_buffer_space_optimized& lhs,
+    circular_buffer_space_optimized& rhs) BOOST_NOEXCEPT {
+    lhs.swap(rhs);
+}
+
+#endif // #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+
+} // namespace boost
+
+#endif // #if !defined(BOOST_CIRCULAR_BUFFER_SPACE_OPTIMIZED_HPP)
diff --git a/libktorrent/miniboost/boost/circular_buffer_fwd.hpp b/libktorrent/miniboost/boost/circular_buffer_fwd.hpp
new file mode 100644
index 00000000..6fdb43e0
--- /dev/null
+++ b/libktorrent/miniboost/boost/circular_buffer_fwd.hpp
@@ -0,0 +1,43 @@
+// Forward declaration of the circular buffer and its adaptor.
+
+// Copyright (c) 2003-2008 Jan Gaspar
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See www.boost.org/libs/circular_buffer for documentation.
+
+#if !defined(BOOST_CIRCULAR_BUFFER_FWD_HPP)
+#define BOOST_CIRCULAR_BUFFER_FWD_HPP
+
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+    #pragma once
+#endif
+
+#include 
+#if !defined(BOOST_NO_STD_ALLOCATOR)
+    #include 
+#else
+    #include 
+#endif
+
+namespace boost {
+
+#if !defined(BOOST_NO_STD_ALLOCATOR)
+    #define BOOST_CB_DEFAULT_ALLOCATOR(T) std::allocator
+#else
+    #define BOOST_CB_DEFAULT_ALLOCATOR(T) BOOST_DEDUCED_TYPENAME std::vector::allocator_type
+#endif
+
+template 
+class circular_buffer;
+
+template 
+class circular_buffer_space_optimized;
+
+#undef BOOST_CB_DEFAULT_ALLOCATOR
+
+} // namespace boost
+
+#endif // #if !defined(BOOST_CIRCULAR_BUFFER_FWD_HPP)
diff --git a/libktorrent/miniboost/boost/concept/assert.hpp b/libktorrent/miniboost/boost/concept/assert.hpp
new file mode 100644
index 00000000..cf981795
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/assert.hpp
@@ -0,0 +1,45 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_ASSERT_DWA2006430_HPP
+# define BOOST_CONCEPT_ASSERT_DWA2006430_HPP
+
+# include 
+# include 
+
+// The old protocol used a constraints() member function in concept
+// checking classes.  If the compiler supports SFINAE, we can detect
+// that function and seamlessly support the old concept checking
+// classes.  In this release, backward compatibility with the old
+// concept checking classes is enabled by default, where available.
+// The old protocol is deprecated, though, and backward compatibility
+// will no longer be the default in the next release.
+
+# if !defined(BOOST_NO_OLD_CONCEPT_SUPPORT)                                         \
+    && !defined(BOOST_NO_SFINAE)                                                    \
+                                                                                    \
+    && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4))
+
+// Note: gcc-2.96 through 3.3.x have some SFINAE, but no ability to
+// check for the presence of particularmember functions.
+
+#  define BOOST_OLD_CONCEPT_SUPPORT
+
+# endif
+
+# ifdef BOOST_MSVC
+#  include 
+# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#  include 
+# else 
+#  include 
+# endif
+
+  // Usage, in class or function context:
+  //
+  //     BOOST_CONCEPT_ASSERT((UnaryFunctionConcept));
+  //
+# define BOOST_CONCEPT_ASSERT(ModelInParens) \
+    BOOST_CONCEPT_ASSERT_FN(void(*)ModelInParens)
+
+#endif // BOOST_CONCEPT_ASSERT_DWA2006430_HPP
diff --git a/libktorrent/miniboost/boost/concept/detail/backward_compatibility.hpp b/libktorrent/miniboost/boost/concept/detail/backward_compatibility.hpp
new file mode 100644
index 00000000..66d573ef
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/backward_compatibility.hpp
@@ -0,0 +1,16 @@
+// Copyright David Abrahams 2009. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
+# define BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
+
+namespace boost
+{
+  namespace concepts {}
+
+# if defined(BOOST_HAS_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD)
+  namespace concept = concepts;
+# endif 
+} // namespace boost::concept
+
+#endif // BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
diff --git a/libktorrent/miniboost/boost/concept/detail/borland.hpp b/libktorrent/miniboost/boost/concept/detail/borland.hpp
new file mode 100644
index 00000000..300d5d40
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/borland.hpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
+# define BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
+
+# include 
+# include 
+
+namespace boost { namespace concepts {
+
+template 
+struct require;
+
+template 
+struct require
+{
+    enum { instantiate = sizeof((((Model*)0)->~Model()), 3) };
+};
+
+#  define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )         \
+  enum                                                  \
+  {                                                     \
+      BOOST_PP_CAT(boost_concept_check,__LINE__) =      \
+      boost::concepts::require::instantiate  \
+  }
+
+}} // namespace boost::concept
+
+#endif // BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
diff --git a/libktorrent/miniboost/boost/concept/detail/concept_def.hpp b/libktorrent/miniboost/boost/concept/detail/concept_def.hpp
new file mode 100644
index 00000000..750561ee
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/concept_def.hpp
@@ -0,0 +1,34 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
+# define BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
+# include 
+# include 
+# include 
+# include 
+#endif // BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
+
+// BOOST_concept(SomeName, (p1)(p2)...(pN))
+//
+// Expands to "template  struct SomeName"
+//
+// Also defines an equivalent SomeNameConcept for backward compatibility.
+// Maybe in the next release we can kill off the "Concept" suffix for good.
+# define BOOST_concept(name, params)                                            \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct name; /* forward declaration */                                      \
+                                                                                \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct BOOST_PP_CAT(name,Concept)                                           \
+      : name< BOOST_PP_SEQ_ENUM(params) >                                       \
+    {                                                                           \
+    };                                                                          \
+                                                                                \
+    template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) >       \
+    struct name                                                                
+    
+// Helper for BOOST_concept, above.
+# define BOOST_CONCEPT_typename(r, ignored, index, t) \
+    BOOST_PP_COMMA_IF(index) typename t
+
diff --git a/libktorrent/miniboost/boost/concept/detail/concept_undef.hpp b/libktorrent/miniboost/boost/concept/detail/concept_undef.hpp
new file mode 100755
index 00000000..713db891
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/concept_undef.hpp
@@ -0,0 +1,5 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# undef BOOST_concept_typename
+# undef BOOST_concept
diff --git a/libktorrent/miniboost/boost/concept/detail/general.hpp b/libktorrent/miniboost/boost/concept/detail/general.hpp
new file mode 100644
index 00000000..c88a1edd
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/general.hpp
@@ -0,0 +1,84 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
+# define BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
+
+# include 
+# include 
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+#  include 
+#  include 
+# endif
+
+// This implementation works on Comeau and GCC, all the way back to
+// 2.95
+namespace boost { namespace concepts {
+
+template 
+struct requirement_;
+
+namespace detail
+{
+  template  struct instantiate {};
+}
+
+template 
+struct requirement
+{
+    static void failed() { ((Model*)0)->~Model(); }
+};
+
+struct failed {};
+
+template 
+struct requirement
+{
+    static void failed() { ((Model*)0)->~Model(); }
+};
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+
+template 
+struct constraint
+{
+    static void failed() { ((Model*)0)->constraints(); }
+};
+  
+template 
+struct requirement_
+  : mpl::if_<
+        concepts::not_satisfied
+      , constraint
+      , requirement
+    >::type
+{};
+  
+# else
+
+// For GCC-2.x, these can't have exactly the same name
+template 
+struct requirement_
+    : requirement
+{};
+  
+# endif
+
+// Version check from https://svn.boost.org/trac/boost/changeset/82886
+// (boost/static_assert.hpp)
+#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) 
+#define BOOST_CONCEPT_UNUSED_TYPEDEF __attribute__((unused))
+#else
+#define BOOST_CONCEPT_UNUSED_TYPEDEF /**/
+#endif
+
+#  define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )             \
+    typedef ::boost::concepts::detail::instantiate<          \
+    &::boost::concepts::requirement_::failed>    \
+      BOOST_PP_CAT(boost_concept_check,__LINE__)             \
+      BOOST_CONCEPT_UNUSED_TYPEDEF
+
+}}
+
+#endif // BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
diff --git a/libktorrent/miniboost/boost/concept/detail/has_constraints.hpp b/libktorrent/miniboost/boost/concept/detail/has_constraints.hpp
new file mode 100644
index 00000000..a309db3d
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/has_constraints.hpp
@@ -0,0 +1,50 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
+# define BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
+
+# include 
+# include 
+# include 
+
+namespace boost { namespace concepts {
+
+namespace detail
+{ 
+
+// Here we implement the metafunction that detects whether a
+// constraints metafunction exists
+  typedef char yes;
+  typedef char (&no)[2];
+
+  template 
+  struct wrap_constraints {};
+    
+#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580) || defined(__CUDACC__)
+  // Work around the following bogus error in Sun Studio 11, by
+  // turning off the has_constraints function entirely:
+  //    Error: complex expression not allowed in dependent template
+  //    argument expression
+  inline no has_constraints_(...);
+#else
+  template 
+  inline yes has_constraints_(Model*, wrap_constraints* = 0);
+  inline no has_constraints_(...);
+#endif
+}
+
+// This would be called "detail::has_constraints," but it has a strong
+// tendency to show up in error messages.
+template 
+struct not_satisfied
+{
+    BOOST_STATIC_CONSTANT(
+        bool
+      , value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes) );
+    typedef mpl::bool_ type;
+};
+
+}} // namespace boost::concepts::detail
+
+#endif // BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
diff --git a/libktorrent/miniboost/boost/concept/detail/msvc.hpp b/libktorrent/miniboost/boost/concept/detail/msvc.hpp
new file mode 100644
index 00000000..078dd223
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/detail/msvc.hpp
@@ -0,0 +1,123 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
+# define BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
+
+# include 
+# include 
+# include 
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+#  include 
+#  include 
+# endif
+
+# ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable:4100)
+# endif
+
+namespace boost { namespace concepts {
+
+
+template 
+struct check
+{
+    virtual void failed(Model* x)
+    {
+        x->~Model();
+    }
+};
+
+# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
+struct failed {};
+template 
+struct check
+{
+    virtual void failed(Model* x)
+    {
+        x->~Model();
+    }
+};
+# endif
+
+# ifdef BOOST_OLD_CONCEPT_SUPPORT
+  
+namespace detail
+{
+  // No need for a virtual function here, since evaluating
+  // not_satisfied below will have already instantiated the
+  // constraints() member.
+  struct constraint {};
+}
+
+template 
+struct require
+  : mpl::if_c<
+        not_satisfied::value
+      , detail::constraint
+# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
+      , check
+# else
+      , check
+# endif 
+        >::type
+{};
+      
+# else
+  
+template 
+struct require
+# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
+    : check
+# else
+    : check
+# endif 
+{};
+  
+# endif
+    
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+//
+// The iterator library sees some really strange errors unless we
+// do things this way.
+//
+template 
+struct require
+{
+    virtual void failed(Model*)
+    {
+        require();
+    }
+};
+
+# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )      \
+enum                                                \
+{                                                   \
+    BOOST_PP_CAT(boost_concept_check,__LINE__) =    \
+    sizeof(::boost::concepts::require)    \
+}
+  
+# else // Not vc-7.1
+  
+template 
+require
+require_(void(*)(Model));
+  
+# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr )          \
+enum                                                    \
+{                                                       \
+    BOOST_PP_CAT(boost_concept_check,__LINE__) =        \
+      sizeof(::boost::concepts::require_((ModelFnPtr)0)) \
+}
+  
+# endif
+}}
+
+# ifdef BOOST_MSVC
+#  pragma warning(pop)
+# endif
+
+#endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
diff --git a/libktorrent/miniboost/boost/concept/usage.hpp b/libktorrent/miniboost/boost/concept/usage.hpp
new file mode 100644
index 00000000..e73370fb
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept/usage.hpp
@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONCEPT_USAGE_DWA2006919_HPP
+# define BOOST_CONCEPT_USAGE_DWA2006919_HPP
+
+# include 
+# include 
+# include 
+
+namespace boost { namespace concepts { 
+
+template 
+struct usage_requirements
+{
+    ~usage_requirements() { ((Model*)0)->~Model(); }
+};
+
+#  if BOOST_WORKAROUND(__GNUC__, <= 3)
+
+#   define BOOST_CONCEPT_USAGE(model)                                    \
+      model(); /* at least 2.96 and 3.4.3 both need this :( */           \
+      BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements)); \
+      ~model()
+
+#  else
+
+#   define BOOST_CONCEPT_USAGE(model)                                    \
+      BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements)); \
+      ~model()
+
+#  endif
+
+}} // namespace boost::concepts
+
+#endif // BOOST_CONCEPT_USAGE_DWA2006919_HPP
diff --git a/libktorrent/miniboost/boost/concept_check.hpp b/libktorrent/miniboost/boost/concept_check.hpp
new file mode 100644
index 00000000..292f37d3
--- /dev/null
+++ b/libktorrent/miniboost/boost/concept_check.hpp
@@ -0,0 +1,1085 @@
+//
+// (C) Copyright Jeremy Siek 2000.
+// Copyright 2002 The Trustees of Indiana University.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Revision History:
+//   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)
+//   02 April 2001: Removed limits header altogether. (Jeremy Siek)
+//   01 April 2001: Modified to use new  header. (JMaddock)
+//
+
+// See http://www.boost.org/libs/concept_check for documentation.
+
+#ifndef BOOST_CONCEPT_CHECKS_HPP
+# define BOOST_CONCEPT_CHECKS_HPP
+
+# include 
+
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+
+# include 
+# include 
+
+#if (defined _MSC_VER)
+# pragma warning( push )
+# pragma warning( disable : 4510 ) // default constructor could not be generated
+# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
+#endif
+
+namespace boost
+{
+
+  //
+  // Backward compatibility
+  //
+
+  template 
+  inline void function_requires(Model* = 0)
+  {
+      BOOST_CONCEPT_ASSERT((Model));
+  }
+  template  inline void ignore_unused_variable_warning(T const&) {}
+
+#  define BOOST_CLASS_REQUIRE(type_var, ns, concept)    \
+    BOOST_CONCEPT_ASSERT((ns::concept))
+
+#  define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept)   \
+    BOOST_CONCEPT_ASSERT((ns::concept))
+
+#  define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept)  \
+    BOOST_CONCEPT_ASSERT((ns::concept))
+
+#  define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
+    BOOST_CONCEPT_ASSERT((ns::concept))
+
+
+  //
+  // Begin concept definitions
+  //
+  BOOST_concept(Integer, (T))
+  {
+      BOOST_CONCEPT_USAGE(Integer)
+        {
+            x.error_type_must_be_an_integer_type();
+        }
+   private:
+      T x;
+  };
+
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+  template <> struct Integer {};
+# if defined(BOOST_HAS_LONG_LONG)
+  template <> struct Integer< ::boost::long_long_type> {};
+  template <> struct Integer< ::boost::ulong_long_type> {};
+# elif defined(BOOST_HAS_MS_INT64)
+  template <> struct Integer<__int64> {};
+  template <> struct Integer {};
+# endif
+
+  BOOST_concept(SignedInteger,(T)) {
+    BOOST_CONCEPT_USAGE(SignedInteger) {
+      x.error_type_must_be_a_signed_integer_type();
+    }
+   private:
+    T x;
+  };
+  template <> struct SignedInteger { };
+  template <> struct SignedInteger {};
+  template <> struct SignedInteger {};
+  template <> struct SignedInteger {};
+# if defined(BOOST_HAS_LONG_LONG)
+  template <> struct SignedInteger< ::boost::long_long_type> {};
+# elif defined(BOOST_HAS_MS_INT64)
+  template <> struct SignedInteger<__int64> {};
+# endif
+
+  BOOST_concept(UnsignedInteger,(T)) {
+    BOOST_CONCEPT_USAGE(UnsignedInteger) {
+      x.error_type_must_be_an_unsigned_integer_type();
+    }
+   private:
+    T x;
+  };
+
+  template <> struct UnsignedInteger {};
+  template <> struct UnsignedInteger {};
+  template <> struct UnsignedInteger {};
+  template <> struct UnsignedInteger {};
+# if defined(BOOST_HAS_LONG_LONG)
+  template <> struct UnsignedInteger< ::boost::ulong_long_type> {};
+# elif defined(BOOST_HAS_MS_INT64)
+  template <> struct UnsignedInteger {};
+# endif
+
+  //===========================================================================
+  // Basic Concepts
+
+  BOOST_concept(DefaultConstructible,(TT))
+  {
+    BOOST_CONCEPT_USAGE(DefaultConstructible) {
+      TT a;               // require default constructor
+      ignore_unused_variable_warning(a);
+    }
+  };
+
+  BOOST_concept(Assignable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(Assignable) {
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = b;             // require assignment operator
+#endif
+      const_constraints(b);
+    }
+   private:
+    void const_constraints(const TT& x) {
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = x;              // const required for argument to assignment
+#else
+      ignore_unused_variable_warning(x);
+#endif
+    }
+   private:
+    TT a;
+    TT b;
+  };
+
+
+  BOOST_concept(CopyConstructible,(TT))
+  {
+    BOOST_CONCEPT_USAGE(CopyConstructible) {
+      TT a(b);            // require copy constructor
+      TT* ptr = &a;       // require address of operator
+      const_constraints(a);
+      ignore_unused_variable_warning(ptr);
+    }
+   private:
+    void const_constraints(const TT& a) {
+      TT c(a);            // require const copy constructor
+      const TT* ptr = &a; // require const address of operator
+      ignore_unused_variable_warning(c);
+      ignore_unused_variable_warning(ptr);
+    }
+    TT b;
+  };
+
+  // The SGI STL version of Assignable requires copy constructor and operator=
+  BOOST_concept(SGIAssignable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(SGIAssignable) {
+      TT c(a);
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = b;              // require assignment operator
+#endif
+      const_constraints(b);
+      ignore_unused_variable_warning(c);
+    }
+   private:
+    void const_constraints(const TT& x) {
+      TT c(x);
+#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
+      a = x;              // const required for argument to assignment
+#endif
+      ignore_unused_variable_warning(c);
+    }
+    TT a;
+    TT b;
+  };
+
+  BOOST_concept(Convertible,(X)(Y))
+  {
+    BOOST_CONCEPT_USAGE(Convertible) {
+      Y y = x;
+      ignore_unused_variable_warning(y);
+    }
+   private:
+    X x;
+  };
+
+  // The C++ standard requirements for many concepts talk about return
+  // types that must be "convertible to bool".  The problem with this
+  // requirement is that it leaves the door open for evil proxies that
+  // define things like operator|| with strange return types.  Two
+  // possible solutions are:
+  // 1) require the return type to be exactly bool
+  // 2) stay with convertible to bool, and also
+  //    specify stuff about all the logical operators.
+  // For now we just test for convertible to bool.
+  template 
+  void require_boolean_expr(const TT& t) {
+    bool x = t;
+    ignore_unused_variable_warning(x);
+  }
+
+  BOOST_concept(EqualityComparable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(EqualityComparable) {
+      require_boolean_expr(a == b);
+      require_boolean_expr(a != b);
+    }
+   private:
+    TT a, b;
+  };
+
+  BOOST_concept(LessThanComparable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(LessThanComparable) {
+      require_boolean_expr(a < b);
+    }
+   private:
+    TT a, b;
+  };
+
+  // This is equivalent to SGI STL's LessThanComparable.
+  BOOST_concept(Comparable,(TT))
+  {
+    BOOST_CONCEPT_USAGE(Comparable) {
+      require_boolean_expr(a < b);
+      require_boolean_expr(a > b);
+      require_boolean_expr(a <= b);
+      require_boolean_expr(a >= b);
+    }
+   private:
+    TT a, b;
+  };
+
+#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME)    \
+  BOOST_concept(NAME, (First)(Second))                          \
+  {                                                             \
+      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                         \
+     private:                                                   \
+        bool constraints_() { return a OP b; }                  \
+        First a;                                                \
+        Second b;                                               \
+  }
+
+#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME)    \
+  BOOST_concept(NAME, (Ret)(First)(Second))                 \
+  {                                                         \
+      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                     \
+  private:                                                  \
+      Ret constraints_() { return a OP b; }                 \
+      First a;                                              \
+      Second b;                                             \
+  }
+
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOp);
+  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOp);
+
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOp);
+  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOp);
+
+  //===========================================================================
+  // Function Object Concepts
+
+  BOOST_concept(Generator,(Func)(Return))
+  {
+      BOOST_CONCEPT_USAGE(Generator) { test(is_void()); }
+
+   private:
+      void test(boost::mpl::false_)
+      {
+          // Do we really want a reference here?
+          const Return& r = f();
+          ignore_unused_variable_warning(r);
+      }
+
+      void test(boost::mpl::true_)
+      {
+          f();
+      }
+
+      Func f;
+  };
+
+  BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
+  {
+      BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void()); }
+
+   private:
+      void test(boost::mpl::false_)
+      {
+          f(arg);               // "priming the pump" this way keeps msvc6 happy (ICE)
+          Return r = f(arg);
+          ignore_unused_variable_warning(r);
+      }
+
+      void test(boost::mpl::true_)
+      {
+          f(arg);
+      }
+
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy construktor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::UnaryFunction::arg"
+      // in class without a constructor [-Wuninitialized])
+      UnaryFunction();
+#endif
+
+      Func f;
+      Arg arg;
+  };
+
+  BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second))
+  {
+      BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void()); }
+   private:
+      void test(boost::mpl::false_)
+      {
+          f(first,second);
+          Return r = f(first, second); // require operator()
+          (void)r;
+      }
+
+      void test(boost::mpl::true_)
+      {
+          f(first,second);
+      }
+
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::BinaryFunction::arg"
+      // in class without a constructor [-Wuninitialized])
+      BinaryFunction();
+#endif
+
+      Func f;
+      First first;
+      Second second;
+  };
+
+  BOOST_concept(UnaryPredicate,(Func)(Arg))
+  {
+    BOOST_CONCEPT_USAGE(UnaryPredicate) {
+      require_boolean_expr(f(arg)); // require operator() returning bool
+    }
+   private:
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::UnaryPredicate::arg"
+      // in class without a constructor [-Wuninitialized])
+      UnaryPredicate();
+#endif
+
+    Func f;
+    Arg arg;
+  };
+
+  BOOST_concept(BinaryPredicate,(Func)(First)(Second))
+  {
+    BOOST_CONCEPT_USAGE(BinaryPredicate) {
+      require_boolean_expr(f(a, b)); // require operator() returning bool
+    }
+   private:
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::BinaryPredicate::arg"
+      // in class without a constructor [-Wuninitialized])
+      BinaryPredicate();
+#endif
+    Func f;
+    First a;
+    Second b;
+  };
+
+  // use this when functor is used inside a container class like std::set
+  BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
+    : BinaryPredicate
+  {
+    BOOST_CONCEPT_USAGE(Const_BinaryPredicate) {
+      const_constraints(f);
+    }
+   private:
+    void const_constraints(const Func& fun) {
+      // operator() must be a const member function
+      require_boolean_expr(fun(a, b));
+    }
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::Const_BinaryPredicate::arg"
+      // in class without a constructor [-Wuninitialized])
+      Const_BinaryPredicate();
+#endif
+
+    Func f;
+    First a;
+    Second b;
+  };
+
+  BOOST_concept(AdaptableGenerator,(Func)(Return))
+    : Generator
+  {
+      typedef typename Func::result_type result_type;
+
+      BOOST_CONCEPT_USAGE(AdaptableGenerator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible));
+      }
+  };
+
+  BOOST_concept(AdaptableUnaryFunction,(Func)(Return)(Arg))
+    : UnaryFunction
+  {
+      typedef typename Func::argument_type argument_type;
+      typedef typename Func::result_type result_type;
+
+      ~AdaptableUnaryFunction()
+      {
+          BOOST_CONCEPT_ASSERT((Convertible));
+          BOOST_CONCEPT_ASSERT((Convertible));
+      }
+  };
+
+  BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second))
+    : BinaryFunction<
+          Func
+        , typename Func::result_type
+        , typename Func::first_argument_type
+        , typename Func::second_argument_type
+      >
+  {
+      typedef typename Func::first_argument_type first_argument_type;
+      typedef typename Func::second_argument_type second_argument_type;
+      typedef typename Func::result_type result_type;
+
+      ~AdaptableBinaryFunction()
+      {
+          BOOST_CONCEPT_ASSERT((Convertible));
+          BOOST_CONCEPT_ASSERT((Convertible));
+          BOOST_CONCEPT_ASSERT((Convertible));
+      }
+  };
+
+  BOOST_concept(AdaptablePredicate,(Func)(Arg))
+    : UnaryPredicate
+    , AdaptableUnaryFunction
+  {
+  };
+
+  BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second))
+    : BinaryPredicate
+    , AdaptableBinaryFunction
+  {
+  };
+
+  //===========================================================================
+  // Iterator Concepts
+
+  BOOST_concept(InputIterator,(TT))
+    : Assignable
+    , EqualityComparable
+  {
+      typedef typename boost::detail::iterator_traits::value_type value_type;
+      typedef typename boost::detail::iterator_traits::difference_type difference_type;
+      typedef typename boost::detail::iterator_traits::reference reference;
+      typedef typename boost::detail::iterator_traits::pointer pointer;
+      typedef typename boost::detail::iterator_traits::iterator_category iterator_category;
+
+      BOOST_CONCEPT_USAGE(InputIterator)
+      {
+        BOOST_CONCEPT_ASSERT((SignedInteger));
+        BOOST_CONCEPT_ASSERT((Convertible));
+
+        TT j(i);
+        (void)*i;           // require dereference operator
+        ++j;                // require preincrement operator
+        i++;                // require postincrement operator
+      }
+   private:
+    TT i;
+  };
+
+  BOOST_concept(OutputIterator,(TT)(ValueT))
+    : Assignable
+  {
+    BOOST_CONCEPT_USAGE(OutputIterator) {
+
+      ++i;                // require preincrement operator
+      i++;                // require postincrement operator
+      *i++ = t;           // require postincrement and assignment
+    }
+   private:
+    TT i, j;
+    ValueT t;
+  };
+
+  BOOST_concept(ForwardIterator,(TT))
+    : InputIterator
+  {
+      BOOST_CONCEPT_USAGE(ForwardIterator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<
+              BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
+            , std::forward_iterator_tag
+          >));
+
+          typename InputIterator::reference r = *i;
+          ignore_unused_variable_warning(r);
+      }
+
+   private:
+      TT i;
+  };
+
+  BOOST_concept(Mutable_ForwardIterator,(TT))
+    : ForwardIterator
+  {
+      BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
+        *i++ = *j;         // require postincrement and assignment
+      }
+   private:
+      TT i, j;
+  };
+
+  BOOST_concept(BidirectionalIterator,(TT))
+    : ForwardIterator
+  {
+      BOOST_CONCEPT_USAGE(BidirectionalIterator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<
+              BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
+            , std::bidirectional_iterator_tag
+          >));
+
+          --i;                // require predecrement operator
+          i--;                // require postdecrement operator
+      }
+   private:
+      TT i;
+  };
+
+  BOOST_concept(Mutable_BidirectionalIterator,(TT))
+    : BidirectionalIterator
+    , Mutable_ForwardIterator
+  {
+      BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
+      {
+          *i-- = *j;                  // require postdecrement and assignment
+      }
+   private:
+      TT i, j;
+  };
+
+  BOOST_concept(RandomAccessIterator,(TT))
+    : BidirectionalIterator
+    , Comparable
+  {
+      BOOST_CONCEPT_USAGE(RandomAccessIterator)
+      {
+          BOOST_CONCEPT_ASSERT((Convertible<
+              BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
+            , std::random_access_iterator_tag
+          >));
+
+          i += n;             // require assignment addition operator
+          i = i + n; i = n + i; // require addition with difference type
+          i -= n;             // require assignment subtraction operator
+          i = i - n;                  // require subtraction with difference type
+          n = i - j;                  // require difference operator
+          (void)i[n];                 // require element access operator
+      }
+
+   private:
+    TT a, b;
+    TT i, j;
+      typename boost::detail::iterator_traits::difference_type n;
+  };
+
+  BOOST_concept(Mutable_RandomAccessIterator,(TT))
+    : RandomAccessIterator
+    , Mutable_BidirectionalIterator
+  {
+      BOOST_CONCEPT_USAGE(Mutable_RandomAccessIterator)
+      {
+          i[n] = *i;                  // require element access and assignment
+      }
+   private:
+    TT i;
+    typename boost::detail::iterator_traits::difference_type n;
+  };
+
+  //===========================================================================
+  // Container s
+
+  BOOST_concept(Container,(C))
+    : Assignable
+  {
+    typedef typename C::value_type value_type;
+    typedef typename C::difference_type difference_type;
+    typedef typename C::size_type size_type;
+    typedef typename C::const_reference const_reference;
+    typedef typename C::const_pointer const_pointer;
+    typedef typename C::const_iterator const_iterator;
+
+      BOOST_CONCEPT_USAGE(Container)
+      {
+          BOOST_CONCEPT_ASSERT((InputIterator));
+          const_constraints(c);
+      }
+
+   private:
+      void const_constraints(const C& cc) {
+          i = cc.begin();
+          i = cc.end();
+          n = cc.size();
+          n = cc.max_size();
+          b = cc.empty();
+      }
+      C c;
+      bool b;
+      const_iterator i;
+      size_type n;
+  };
+
+  BOOST_concept(Mutable_Container,(C))
+    : Container
+  {
+      typedef typename C::reference reference;
+      typedef typename C::iterator iterator;
+      typedef typename C::pointer pointer;
+
+      BOOST_CONCEPT_USAGE(Mutable_Container)
+      {
+          BOOST_CONCEPT_ASSERT((
+               Assignable));
+
+          BOOST_CONCEPT_ASSERT((InputIterator));
+
+          i = c.begin();
+          i = c.end();
+          c.swap(c2);
+      }
+
+   private:
+      iterator i;
+      C c, c2;
+  };
+
+  BOOST_concept(ForwardContainer,(C))
+    : Container
+  {
+      BOOST_CONCEPT_USAGE(ForwardContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+               ForwardIterator<
+                    typename ForwardContainer::const_iterator
+               >));
+      }
+  };
+
+  BOOST_concept(Mutable_ForwardContainer,(C))
+    : ForwardContainer
+    , Mutable_Container
+  {
+      BOOST_CONCEPT_USAGE(Mutable_ForwardContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+               Mutable_ForwardIterator<
+                   typename Mutable_ForwardContainer::iterator
+               >));
+      }
+  };
+
+  BOOST_concept(ReversibleContainer,(C))
+    : ForwardContainer
+  {
+      typedef typename
+        C::const_reverse_iterator
+      const_reverse_iterator;
+
+      BOOST_CONCEPT_USAGE(ReversibleContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+              BidirectionalIterator<
+                  typename ReversibleContainer::const_iterator>));
+
+          BOOST_CONCEPT_ASSERT((BidirectionalIterator));
+
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc)
+      {
+          const_reverse_iterator i = cc.rbegin();
+          i = cc.rend();
+      }
+      C c;
+  };
+
+  BOOST_concept(Mutable_ReversibleContainer,(C))
+    : Mutable_ForwardContainer
+    , ReversibleContainer
+  {
+      typedef typename C::reverse_iterator reverse_iterator;
+
+      BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
+      {
+          typedef typename Mutable_ForwardContainer::iterator iterator;
+          BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator));
+          BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator));
+
+          reverse_iterator i = c.rbegin();
+          i = c.rend();
+      }
+   private:
+      C c;
+  };
+
+  BOOST_concept(RandomAccessContainer,(C))
+    : ReversibleContainer
+  {
+      typedef typename C::size_type size_type;
+      typedef typename C::const_reference const_reference;
+
+      BOOST_CONCEPT_USAGE(RandomAccessContainer)
+      {
+          BOOST_CONCEPT_ASSERT((
+              RandomAccessIterator<
+                  typename RandomAccessContainer::const_iterator
+              >));
+
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc)
+      {
+          const_reference r = cc[n];
+          ignore_unused_variable_warning(r);
+      }
+
+      C c;
+      size_type n;
+  };
+
+  BOOST_concept(Mutable_RandomAccessContainer,(C))
+    : Mutable_ReversibleContainer
+    , RandomAccessContainer
+  {
+   private:
+      typedef Mutable_RandomAccessContainer self;
+   public:
+      BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer)
+      {
+          BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator));
+          BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator));
+
+          typename self::reference r = c[i];
+          ignore_unused_variable_warning(r);
+      }
+
+   private:
+      typename Mutable_ReversibleContainer::size_type i;
+      C c;
+  };
+
+  // A Sequence is inherently mutable
+  BOOST_concept(Sequence,(S))
+    : Mutable_ForwardContainer
+      // Matt Austern's book puts DefaultConstructible here, the C++
+      // standard places it in Container --JGS
+      // ... so why aren't we following the standard?  --DWA
+    , DefaultConstructible
+  {
+      BOOST_CONCEPT_USAGE(Sequence)
+      {
+          S
+              c(n),
+              c2(n, t),
+              c3(first, last);
+
+          c.insert(p, t);
+          c.insert(p, n, t);
+          c.insert(p, first, last);
+
+          c.erase(p);
+          c.erase(p, q);
+
+          typename Sequence::reference r = c.front();
+
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(c2);
+          ignore_unused_variable_warning(c3);
+          ignore_unused_variable_warning(r);
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const S& c) {
+          typename Sequence::const_reference r = c.front();
+          ignore_unused_variable_warning(r);
+      }
+
+      typename S::value_type t;
+      typename S::size_type n;
+      typename S::value_type* first, *last;
+      typename S::iterator p, q;
+  };
+
+  BOOST_concept(FrontInsertionSequence,(S))
+    : Sequence
+  {
+      BOOST_CONCEPT_USAGE(FrontInsertionSequence)
+      {
+          c.push_front(t);
+          c.pop_front();
+      }
+   private:
+      S c;
+      typename S::value_type t;
+  };
+
+  BOOST_concept(BackInsertionSequence,(S))
+    : Sequence
+  {
+      BOOST_CONCEPT_USAGE(BackInsertionSequence)
+      {
+          c.push_back(t);
+          c.pop_back();
+          typename BackInsertionSequence::reference r = c.back();
+          ignore_unused_variable_warning(r);
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const S& cc) {
+          typename BackInsertionSequence::const_reference
+              r = cc.back();
+          ignore_unused_variable_warning(r);
+      }
+      S c;
+      typename S::value_type t;
+  };
+
+  BOOST_concept(AssociativeContainer,(C))
+    : ForwardContainer
+    , DefaultConstructible
+  {
+      typedef typename C::key_type key_type;
+      typedef typename C::key_compare key_compare;
+      typedef typename C::value_compare value_compare;
+      typedef typename C::iterator iterator;
+
+      BOOST_CONCEPT_USAGE(AssociativeContainer)
+      {
+          i = c.find(k);
+          r = c.equal_range(k);
+          c.erase(k);
+          c.erase(i);
+          c.erase(r.first, r.second);
+          const_constraints(c);
+          BOOST_CONCEPT_ASSERT((BinaryPredicate));
+
+          typedef typename AssociativeContainer::value_type value_type_;
+          BOOST_CONCEPT_ASSERT((BinaryPredicate));
+      }
+
+      // Redundant with the base concept, but it helps below.
+      typedef typename C::const_iterator const_iterator;
+   private:
+      void const_constraints(const C& cc)
+      {
+          ci = cc.find(k);
+          n = cc.count(k);
+          cr = cc.equal_range(k);
+      }
+
+      C c;
+      iterator i;
+      std::pair r;
+      const_iterator ci;
+      std::pair cr;
+      typename C::key_type k;
+      typename C::size_type n;
+  };
+
+  BOOST_concept(UniqueAssociativeContainer,(C))
+    : AssociativeContainer
+  {
+      BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
+      {
+          C c(first, last);
+
+          pos_flag = c.insert(t);
+          c.insert(first, last);
+
+          ignore_unused_variable_warning(c);
+      }
+   private:
+      std::pair pos_flag;
+      typename C::value_type t;
+      typename C::value_type* first, *last;
+  };
+
+  BOOST_concept(MultipleAssociativeContainer,(C))
+    : AssociativeContainer
+  {
+      BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
+      {
+          C c(first, last);
+
+          pos = c.insert(t);
+          c.insert(first, last);
+
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(pos);
+      }
+   private:
+      typename C::iterator pos;
+      typename C::value_type t;
+      typename C::value_type* first, *last;
+  };
+
+  BOOST_concept(SimpleAssociativeContainer,(C))
+    : AssociativeContainer
+  {
+      BOOST_CONCEPT_USAGE(SimpleAssociativeContainer)
+      {
+          typedef typename C::key_type key_type;
+          typedef typename C::value_type value_type;
+          BOOST_MPL_ASSERT((boost::is_same));
+      }
+  };
+
+  BOOST_concept(PairAssociativeContainer,(C))
+    : AssociativeContainer
+  {
+      BOOST_CONCEPT_USAGE(PairAssociativeContainer)
+      {
+          typedef typename C::key_type key_type;
+          typedef typename C::value_type value_type;
+          typedef typename C::mapped_type mapped_type;
+          typedef std::pair required_value_type;
+          BOOST_MPL_ASSERT((boost::is_same));
+      }
+  };
+
+  BOOST_concept(SortedAssociativeContainer,(C))
+    : AssociativeContainer
+    , ReversibleContainer
+  {
+      BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
+      {
+          C
+              c(kc),
+              c2(first, last),
+              c3(first, last, kc);
+
+          p = c.upper_bound(k);
+          p = c.lower_bound(k);
+          r = c.equal_range(k);
+
+          c.insert(p, t);
+
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(c2);
+          ignore_unused_variable_warning(c3);
+          const_constraints(c);
+      }
+
+      void const_constraints(const C& c)
+      {
+          kc = c.key_comp();
+          vc = c.value_comp();
+
+          cp = c.upper_bound(k);
+          cp = c.lower_bound(k);
+          cr = c.equal_range(k);
+      }
+
+   private:
+      typename C::key_compare kc;
+      typename C::value_compare vc;
+      typename C::value_type t;
+      typename C::key_type k;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+
+      typedef SortedAssociativeContainer self;
+      iterator p;
+      const_iterator cp;
+      std::pair r;
+      std::pair cr;
+      typename C::value_type* first, *last;
+  };
+
+  // HashedAssociativeContainer
+
+  BOOST_concept(Collection,(C))
+  {
+      BOOST_CONCEPT_USAGE(Collection)
+      {
+        boost::function_requires >();
+        boost::function_requires >();
+        boost::function_requires >();
+        const_constraints(c);
+        i = c.begin();
+        i = c.end();
+        c.swap(c);
+      }
+
+      void const_constraints(const C& cc) {
+        ci = cc.begin();
+        ci = cc.end();
+        n = cc.size();
+        b = cc.empty();
+      }
+
+    private:
+      typedef typename C::value_type value_type;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+      typedef typename C::reference reference;
+      typedef typename C::const_reference const_reference;
+      // typedef typename C::pointer pointer;
+      typedef typename C::difference_type difference_type;
+      typedef typename C::size_type size_type;
+
+      C c;
+      bool b;
+      iterator i;
+      const_iterator ci;
+      size_type n;
+  };
+} // namespace boost
+
+#if (defined _MSC_VER)
+# pragma warning( pop )
+#endif
+
+# include 
+
+#endif // BOOST_CONCEPT_CHECKS_HPP
+
diff --git a/libktorrent/miniboost/boost/config.hpp b/libktorrent/miniboost/boost/config.hpp
new file mode 100644
index 00000000..d49bb27c
--- /dev/null
+++ b/libktorrent/miniboost/boost/config.hpp
@@ -0,0 +1,67 @@
+//  Boost config.hpp configuration header file  ------------------------------//
+
+//  (C) Copyright John Maddock 2002.
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/config for most recent version.
+
+//  Boost config.hpp policy and rationale documentation has been moved to
+//  http://www.boost.org/libs/config
+//
+//  CAUTION: This file is intended to be completely stable -
+//           DO NOT MODIFY THIS FILE!
+//
+
+#ifndef BOOST_CONFIG_HPP
+#define BOOST_CONFIG_HPP
+
+// if we don't have a user config, then use the default location:
+#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG)
+#  define BOOST_USER_CONFIG 
+#if 0
+// For dependency trackers:
+#  include 
+#endif
+#endif
+// include it first:
+#ifdef BOOST_USER_CONFIG
+#  include BOOST_USER_CONFIG
+#endif
+
+// if we don't have a compiler config set, try and find one:
+#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG)
+#  include 
+#endif
+// if we have a compiler config, include it now:
+#ifdef BOOST_COMPILER_CONFIG
+#  include BOOST_COMPILER_CONFIG
+#endif
+
+// if we don't have a std library config set, try and find one:
+#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus)
+#  include 
+#endif
+// if we have a std library config, include it now:
+#ifdef BOOST_STDLIB_CONFIG
+#  include BOOST_STDLIB_CONFIG
+#endif
+
+// if we don't have a platform config set, try and find one:
+#if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG)
+#  include 
+#endif
+// if we have a platform config, include it now:
+#ifdef BOOST_PLATFORM_CONFIG
+#  include BOOST_PLATFORM_CONFIG
+#endif
+
+// get config suffix code:
+#include 
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#endif  // BOOST_CONFIG_HPP
diff --git a/libktorrent/miniboost/boost/config/abi/borland_prefix.hpp b/libktorrent/miniboost/boost/config/abi/borland_prefix.hpp
new file mode 100644
index 00000000..3a0e5ae2
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/abi/borland_prefix.hpp
@@ -0,0 +1,27 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  for C++ Builder the following options effect the ABI:
+//
+//  -b (on or off - effect emum sizes)
+//  -Vx  (on or off - empty members)
+//  -Ve (on or off - empty base classes)
+//  -aX (alignment - 5 options).
+//  -pX (Calling convention - 4 options)
+//  -VmX (member pointer size and layout - 5 options)
+//  -VC (on or off, changes name mangling)
+//  -Vl (on or off, changes struct layout).
+
+//  In addition the following warnings are sufficiently annoying (and
+//  unfixable) to have them turned off by default:
+//
+//  8027 - functions containing [for|while] loops are not expanded inline
+//  8026 - functions taking class by value arguments are not expanded inline
+
+#pragma nopushoptwarn
+#  pragma option push -a8 -Vx- -Ve- -b- -pc -Vmv -VC- -Vl- -w-8027 -w-8026
+
+
+
diff --git a/libktorrent/miniboost/boost/config/abi/borland_suffix.hpp b/libktorrent/miniboost/boost/config/abi/borland_suffix.hpp
new file mode 100644
index 00000000..940535f3
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/abi/borland_suffix.hpp
@@ -0,0 +1,12 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#  pragma option pop
+#pragma nopushoptwarn
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/abi/msvc_prefix.hpp b/libktorrent/miniboost/boost/config/abi/msvc_prefix.hpp
new file mode 100644
index 00000000..97f06cdc
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/abi/msvc_prefix.hpp
@@ -0,0 +1,22 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//
+// Boost binaries are built with the compiler's default ABI settings,
+// if the user changes their default alignment in the VS IDE then their
+// code will no longer be binary compatible with the bjam built binaries
+// unless this header is included to force Boost code into a consistent ABI.
+//
+// Note that inclusion of this header is only necessary for libraries with 
+// separate source, header only libraries DO NOT need this as long as all
+// translation units are built with the same options.
+//
+#if defined(_M_X64)
+#  pragma pack(push,16)
+#else
+#  pragma pack(push,8)
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/abi/msvc_suffix.hpp b/libktorrent/miniboost/boost/config/abi/msvc_suffix.hpp
new file mode 100644
index 00000000..a64d783e
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/abi/msvc_suffix.hpp
@@ -0,0 +1,8 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma pack(pop)
+
+
diff --git a/libktorrent/miniboost/boost/config/abi_prefix.hpp b/libktorrent/miniboost/boost/config/abi_prefix.hpp
new file mode 100644
index 00000000..3b134749
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/abi_prefix.hpp
@@ -0,0 +1,25 @@
+//  abi_prefix header  -------------------------------------------------------//
+
+// (c) Copyright John Maddock 2003
+   
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
+# define BOOST_CONFIG_ABI_PREFIX_HPP
+#else
+# error double inclusion of header boost/config/abi_prefix.hpp is an error
+#endif
+
+#include 
+
+// this must occur after all other includes and before any code appears:
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+
diff --git a/libktorrent/miniboost/boost/config/abi_suffix.hpp b/libktorrent/miniboost/boost/config/abi_suffix.hpp
new file mode 100644
index 00000000..93916166
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/abi_suffix.hpp
@@ -0,0 +1,27 @@
+//  abi_sufffix header  -------------------------------------------------------//
+
+// (c) Copyright John Maddock 2003
+   
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+
+// This header should be #included AFTER code that was preceded by a #include
+// .
+
+#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
+# error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp
+#else
+# undef BOOST_CONFIG_ABI_PREFIX_HPP
+#endif
+
+// the suffix header occurs after all of our code:
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/auto_link.hpp b/libktorrent/miniboost/boost/config/auto_link.hpp
new file mode 100644
index 00000000..13cbad43
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/auto_link.hpp
@@ -0,0 +1,429 @@
+//  (C) Copyright John Maddock 2003.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         auto_link.hpp
+  *   VERSION      see 
+  *   DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers.
+  */
+
+/*************************************************************************
+
+USAGE:
+~~~~~~
+
+Before including this header you must define one or more of define the following macros:
+
+BOOST_LIB_NAME:           Required: A string containing the basename of the library,
+                          for example boost_regex.
+BOOST_LIB_TOOLSET:        Optional: the base name of the toolset.
+BOOST_DYN_LINK:           Optional: when set link to dll rather than static library.
+BOOST_LIB_DIAGNOSTIC:     Optional: when set the header will print out the name
+                          of the library selected (useful for debugging).
+BOOST_AUTO_LINK_NOMANGLE: Specifies that we should link to BOOST_LIB_NAME.lib,
+                          rather than a mangled-name version.
+BOOST_AUTO_LINK_TAGGED:   Specifies that we link to libraries built with the --layout=tagged option.
+                          This is essentially the same as the default name-mangled version, but without
+                          the compiler name and version, or the Boost version.  Just the build options.
+
+These macros will be undef'ed at the end of the header, further this header
+has no include guards - so be sure to include it only once from your library!
+
+Algorithm:
+~~~~~~~~~~
+
+Libraries for Borland and Microsoft compilers are automatically
+selected here, the name of the lib is selected according to the following
+formula:
+
+BOOST_LIB_PREFIX
+   + BOOST_LIB_NAME
+   + "_"
+   + BOOST_LIB_TOOLSET
+   + BOOST_LIB_THREAD_OPT
+   + BOOST_LIB_RT_OPT
+   "-"
+   + BOOST_LIB_VERSION
+
+These are defined as:
+
+BOOST_LIB_PREFIX:     "lib" for static libraries otherwise "".
+
+BOOST_LIB_NAME:       The base name of the lib ( for example boost_regex).
+
+BOOST_LIB_TOOLSET:    The compiler toolset name (vc6, vc7, bcb5 etc).
+
+BOOST_LIB_THREAD_OPT: "-mt" for multithread builds, otherwise nothing.
+
+BOOST_LIB_RT_OPT:     A suffix that indicates the runtime library used,
+                      contains one or more of the following letters after
+                      a hyphen:
+
+                      s      static runtime (dynamic if not present).
+                      g      debug/diagnostic runtime (release if not present).
+                      y      Python debug/diagnostic runtime (release if not present).
+                      d      debug build (release if not present).
+                      p      STLport build.
+                      n      STLport build without its IOStreams.
+
+BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
+
+
+***************************************************************************/
+
+#ifdef __cplusplus
+#  ifndef BOOST_CONFIG_HPP
+#     include 
+#  endif
+#elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__)
+//
+// C language compatability (no, honestly)
+//
+#  define BOOST_MSVC _MSC_VER
+#  define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
+#  define BOOST_DO_STRINGIZE(X) #X
+#endif
+//
+// Only include what follows for known and supported compilers:
+//
+#if defined(BOOST_MSVC) \
+    || defined(__BORLANDC__) \
+    || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
+    || (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200))
+
+#ifndef BOOST_VERSION_HPP
+#  include 
+#endif
+
+#ifndef BOOST_LIB_NAME
+#  error "Macro BOOST_LIB_NAME not set (internal error)"
+#endif
+
+//
+// error check:
+//
+#if defined(__MSVC_RUNTIME_CHECKS) && !defined(_DEBUG)
+#  pragma message("Using the /RTC option without specifying a debug runtime will lead to linker errors")
+#  pragma message("Hint: go to the code generation options and switch to one of the debugging runtimes")
+#  error "Incompatible build options"
+#endif
+//
+// select toolset if not defined already:
+//
+#ifndef BOOST_LIB_TOOLSET
+#  if defined(BOOST_MSVC) && (BOOST_MSVC < 1200)
+    // Note: no compilers before 1200 are supported
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+
+#    ifdef UNDER_CE
+       // eVC4:
+#      define BOOST_LIB_TOOLSET "evc4"
+#    else
+       // vc6:
+#      define BOOST_LIB_TOOLSET "vc6"
+#    endif
+
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1310)
+
+     // vc7:
+#    define BOOST_LIB_TOOLSET "vc7"
+
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1400)
+
+     // vc71:
+#    define BOOST_LIB_TOOLSET "vc71"
+
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1500)
+
+     // vc80:
+#    define BOOST_LIB_TOOLSET "vc80"
+
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1600)
+
+     // vc90:
+#    define BOOST_LIB_TOOLSET "vc90"
+
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1700)
+
+     // vc10:
+#    define BOOST_LIB_TOOLSET "vc100"
+
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1800)
+
+     // vc11:
+#    define BOOST_LIB_TOOLSET "vc110"
+
+#  elif defined(BOOST_MSVC)
+
+     // vc12:
+#    define BOOST_LIB_TOOLSET "vc120"
+
+#  elif defined(__BORLANDC__)
+
+     // CBuilder 6:
+#    define BOOST_LIB_TOOLSET "bcb"
+
+#  elif defined(__ICL)
+
+     // Intel C++, no version number:
+#    define BOOST_LIB_TOOLSET "iw"
+
+#  elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF )
+
+     // Metrowerks CodeWarrior 8.x
+#    define BOOST_LIB_TOOLSET "cw8"
+
+#  elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF )
+
+     // Metrowerks CodeWarrior 9.x
+#    define BOOST_LIB_TOOLSET "cw9"
+
+#  endif
+#endif // BOOST_LIB_TOOLSET
+
+//
+// select thread opt:
+//
+#if defined(_MT) || defined(__MT__)
+#  define BOOST_LIB_THREAD_OPT "-mt"
+#else
+#  define BOOST_LIB_THREAD_OPT
+#endif
+
+#if defined(_MSC_VER) || defined(__MWERKS__)
+
+#  ifdef _DLL
+
+#     if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS))
+
+#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-gydp"
+#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
+#            define BOOST_LIB_RT_OPT "-gdp"
+#        elif defined(_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-gydp"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        elif defined(_DEBUG)
+#            define BOOST_LIB_RT_OPT "-gdp"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        else
+#            define BOOST_LIB_RT_OPT "-p"
+#        endif
+
+#     elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+
+#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-gydpn"
+#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
+#            define BOOST_LIB_RT_OPT "-gdpn"
+#        elif defined(_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-gydpn"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        elif defined(_DEBUG)
+#            define BOOST_LIB_RT_OPT "-gdpn"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        else
+#            define BOOST_LIB_RT_OPT "-pn"
+#        endif
+
+#     else
+
+#        if defined(_DEBUG) && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-gyd"
+#        elif defined(_DEBUG)
+#            define BOOST_LIB_RT_OPT "-gd"
+#        else
+#            define BOOST_LIB_RT_OPT
+#        endif
+
+#     endif
+
+#  else
+
+#     if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS))
+
+#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-sgydp"
+#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
+#            define BOOST_LIB_RT_OPT "-sgdp"
+#        elif defined(_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#             define BOOST_LIB_RT_OPT "-sgydp"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        elif defined(_DEBUG)
+#             define BOOST_LIB_RT_OPT "-sgdp"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        else
+#            define BOOST_LIB_RT_OPT "-sp"
+#        endif
+
+#     elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+
+#        if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#            define BOOST_LIB_RT_OPT "-sgydpn"
+#        elif defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG))
+#            define BOOST_LIB_RT_OPT "-sgdpn"
+#        elif defined(_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#             define BOOST_LIB_RT_OPT "-sgydpn"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        elif defined(_DEBUG)
+#             define BOOST_LIB_RT_OPT "-sgdpn"
+#            pragma message("warning: STLport debug versions are built with /D_STLP_DEBUG=1")
+#            error "Build options aren't compatible with pre-built libraries"
+#        else
+#            define BOOST_LIB_RT_OPT "-spn"
+#        endif
+
+#     else
+
+#        if defined(_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#             define BOOST_LIB_RT_OPT "-sgyd"
+#        elif defined(_DEBUG)
+#             define BOOST_LIB_RT_OPT "-sgd"
+#        else
+#            define BOOST_LIB_RT_OPT "-s"
+#        endif
+
+#     endif
+
+#  endif
+
+#elif defined(__BORLANDC__)
+
+//
+// figure out whether we want the debug builds or not:
+//
+#if __BORLANDC__ > 0x561
+#pragma defineonoption BOOST_BORLAND_DEBUG -v
+#endif
+//
+// sanity check:
+//
+#if defined(__STL_DEBUG) || defined(_STLP_DEBUG)
+#error "Pre-built versions of the Boost libraries are not provided in STLport-debug form"
+#endif
+
+#  ifdef _RTLDLL
+
+#     if defined(BOOST_BORLAND_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#         define BOOST_LIB_RT_OPT "-yd"
+#     elif defined(BOOST_BORLAND_DEBUG)
+#         define BOOST_LIB_RT_OPT "-d"
+#     elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#         define BOOST_LIB_RT_OPT -y
+#     else
+#         define BOOST_LIB_RT_OPT
+#     endif
+
+#  else
+
+#     if defined(BOOST_BORLAND_DEBUG)\
+               && defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#         define BOOST_LIB_RT_OPT "-syd"
+#     elif defined(BOOST_BORLAND_DEBUG)
+#         define BOOST_LIB_RT_OPT "-sd"
+#     elif defined(BOOST_DEBUG_PYTHON) && defined(BOOST_LINKING_PYTHON)
+#         define BOOST_LIB_RT_OPT "-sy"
+#     else
+#         define BOOST_LIB_RT_OPT "-s"
+#     endif
+
+#  endif
+
+#endif
+
+//
+// select linkage opt:
+//
+#if (defined(_DLL) || defined(_RTLDLL)) && defined(BOOST_DYN_LINK)
+#  define BOOST_LIB_PREFIX
+#elif defined(BOOST_DYN_LINK)
+#  error "Mixing a dll boost library with a static runtime is a really bad idea..."
+#else
+#  define BOOST_LIB_PREFIX "lib"
+#endif
+
+//
+// now include the lib:
+//
+#if defined(BOOST_LIB_NAME) \
+      && defined(BOOST_LIB_PREFIX) \
+      && defined(BOOST_LIB_TOOLSET) \
+      && defined(BOOST_LIB_THREAD_OPT) \
+      && defined(BOOST_LIB_RT_OPT) \
+      && defined(BOOST_LIB_VERSION)
+
+#ifdef BOOST_AUTO_LINK_TAGGED
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
+#  ifdef BOOST_LIB_DIAGNOSTIC
+#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
+#  endif
+#elif defined(BOOST_AUTO_LINK_NOMANGLE)
+#  pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+#  ifdef BOOST_LIB_DIAGNOSTIC
+#     pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+#  endif
+#else
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+#  ifdef BOOST_LIB_DIAGNOSTIC
+#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+#  endif
+#endif
+
+#else
+#  error "some required macros where not defined (internal logic error)."
+#endif
+
+
+#endif // _MSC_VER || __BORLANDC__
+
+//
+// finally undef any macros we may have set:
+//
+#ifdef BOOST_LIB_PREFIX
+#  undef BOOST_LIB_PREFIX
+#endif
+#if defined(BOOST_LIB_NAME)
+#  undef BOOST_LIB_NAME
+#endif
+// Don't undef this one: it can be set by the user and should be the 
+// same for all libraries:
+//#if defined(BOOST_LIB_TOOLSET)
+//#  undef BOOST_LIB_TOOLSET
+//#endif
+#if defined(BOOST_LIB_THREAD_OPT)
+#  undef BOOST_LIB_THREAD_OPT
+#endif
+#if defined(BOOST_LIB_RT_OPT)
+#  undef BOOST_LIB_RT_OPT
+#endif
+#if defined(BOOST_LIB_LINK_OPT)
+#  undef BOOST_LIB_LINK_OPT
+#endif
+#if defined(BOOST_LIB_DEBUG_OPT)
+#  undef BOOST_LIB_DEBUG_OPT
+#endif
+#if defined(BOOST_DYN_LINK)
+#  undef BOOST_DYN_LINK
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/borland.hpp b/libktorrent/miniboost/boost/config/compiler/borland.hpp
new file mode 100644
index 00000000..d2a09024
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/borland.hpp
@@ -0,0 +1,288 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Aleksey Gurtovoy 2002.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Borland C++ compiler setup:
+
+//
+// versions check:
+// we don't support Borland prior to version 5.4:
+#if __BORLANDC__ < 0x540
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+
+// last known compiler version:
+#if (__BORLANDC__ > 0x613)
+//#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+//#  else
+//#     pragma message( "Unknown compiler version - please run the configure tests and report the results")
+//#  endif
+#elif (__BORLANDC__ == 0x600)
+#  error "CBuilderX preview compiler is no longer supported"
+#endif
+
+//
+// Support macros to help with standard library detection
+#if (__BORLANDC__ < 0x560) || defined(_USE_OLD_RW_STL)
+#  define BOOST_BCB_WITH_ROGUE_WAVE
+#elif __BORLANDC__ < 0x570
+#  define BOOST_BCB_WITH_STLPORT
+#else
+#  define BOOST_BCB_WITH_DINKUMWARE
+#endif
+
+//
+// Version 5.0 and below:
+#   if __BORLANDC__ <= 0x0550
+// Borland C++Builder 4 and 5:
+#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#     if __BORLANDC__ == 0x0550
+// Borland C++Builder 5, command-line compiler 5.5:
+#       define BOOST_NO_OPERATORS_IN_NAMESPACE
+#     endif
+// Variadic macros do not exist for C++ Builder versions 5 and below
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#   endif
+
+// Version 5.51 and below:
+#if (__BORLANDC__ <= 0x551)
+#  define BOOST_NO_CV_SPECIALIZATIONS
+#  define BOOST_NO_CV_VOID_SPECIALIZATIONS
+#  define BOOST_NO_DEDUCED_TYPENAME
+// workaround for missing WCHAR_MAX/WCHAR_MIN:
+#ifdef __cplusplus
+#include 
+#include 
+#else
+#include 
+#include 
+#endif // __cplusplus
+#ifndef WCHAR_MAX
+#  define WCHAR_MAX 0xffff
+#endif
+#ifndef WCHAR_MIN
+#  define WCHAR_MIN 0
+#endif
+#endif
+
+// Borland C++ Builder 6 and below:
+#if (__BORLANDC__ <= 0x564)
+
+#  if defined(NDEBUG) && defined(__cplusplus)
+      // fix broken  so that Boost.test works:
+#     include 
+#     undef strcmp
+#  endif
+   // fix broken errno declaration:
+#  include 
+#  ifndef errno
+#     define errno errno
+#  endif
+
+#endif
+
+//
+// new bug in 5.61:
+#if (__BORLANDC__ >= 0x561) && (__BORLANDC__ <= 0x580)
+   // this seems to be needed by the command line compiler, but not the IDE:
+#  define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
+#endif
+
+// Borland C++ Builder 2006 Update 2 and below:
+#if (__BORLANDC__ <= 0x582)
+#  define BOOST_NO_SFINAE
+#  define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
+#  define BOOST_NO_TEMPLATE_TEMPLATES
+
+#  define BOOST_NO_PRIVATE_IN_AGGREGATE
+
+#  ifdef _WIN32
+#     define BOOST_NO_SWPRINTF
+#  elif defined(linux) || defined(__linux__) || defined(__linux)
+      // we should really be able to do without this
+      // but the wcs* functions aren't imported into std::
+#     define BOOST_NO_STDC_NAMESPACE
+      // _CPPUNWIND doesn't get automatically set for some reason:
+#     pragma defineonoption BOOST_CPPUNWIND -x
+#  endif
+#endif
+
+#if (__BORLANDC__ <= 0x613)  // Beman has asked Alisdair for more info
+   // we shouldn't really need this - but too many things choke
+   // without it, this needs more investigation:
+#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#  define BOOST_NO_IS_ABSTRACT
+#  define BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
+#  define BOOST_NO_USING_TEMPLATE
+#  define BOOST_SP_NO_SP_CONVERTIBLE
+
+// Temporary workaround
+#define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif
+
+// Borland C++ Builder 2008 and below:
+#  define BOOST_NO_INTEGRAL_INT64_T
+#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
+#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+#  define BOOST_NO_NESTED_FRIENDSHIP
+#  define BOOST_NO_TYPENAME_WITH_CTOR
+#if (__BORLANDC__ < 0x600)
+#  define BOOST_ILLEGAL_CV_REFERENCES
+#endif
+
+//
+//  Positive Feature detection
+//
+// Borland C++ Builder 2008 and below:
+#if (__BORLANDC__ >= 0x599)
+#  pragma defineonoption BOOST_CODEGEAR_0X_SUPPORT -Ax
+#endif
+//
+// C++0x Macros:
+//
+#if !defined( BOOST_CODEGEAR_0X_SUPPORT ) || (__BORLANDC__ < 0x610)
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#  define BOOST_NO_CXX11_DECLTYPE
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#else
+#  define BOOST_HAS_ALIGNOF
+#  define BOOST_HAS_CHAR16_T
+#  define BOOST_HAS_CHAR32_T
+#  define BOOST_HAS_DECLTYPE
+#  define BOOST_HAS_EXPLICIT_CONVERSION_OPS
+#  define BOOST_HAS_REF_QUALIFIER
+#  define BOOST_HAS_RVALUE_REFS
+#  define BOOST_HAS_STATIC_ASSERT
+#endif
+
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS    // UTF-8 still not supported
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+#if __BORLANDC__ >= 0x590
+#  define BOOST_HAS_TR1_HASH
+
+#  define BOOST_HAS_MACRO_USE_FACET
+#endif
+
+//
+// Post 0x561 we have long long and stdint.h:
+#if __BORLANDC__ >= 0x561
+#  ifndef __NO_LONG_LONG
+#     define BOOST_HAS_LONG_LONG
+#  else
+#     define BOOST_NO_LONG_LONG
+#  endif
+   // On non-Win32 platforms let the platform config figure this out:
+#  ifdef _WIN32
+#      define BOOST_HAS_STDINT_H
+#  endif
+#endif
+
+// Borland C++Builder 6 defaults to using STLPort.  If _USE_OLD_RW_STL is
+// defined, then we have 0x560 or greater with the Rogue Wave implementation
+// which presumably has the std::DBL_MAX bug.
+#if defined( BOOST_BCB_WITH_ROGUE_WAVE )
+//  is partly broken, some macros define symbols that are really in
+// namespace std, so you end up having to use illegal constructs like
+// std::DBL_MAX, as a fix we'll just include float.h and have done with:
+#include 
+#endif
+//
+// __int64:
+//
+#if (__BORLANDC__ >= 0x530) && !defined(__STRICT_ANSI__)
+#  define BOOST_HAS_MS_INT64
+#endif
+//
+// check for exception handling support:
+//
+#if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+//
+// all versions have a :
+//
+#ifndef __STRICT_ANSI__
+#  define BOOST_HAS_DIRENT_H
+#endif
+//
+// all versions support __declspec:
+//
+#if defined(__STRICT_ANSI__)
+// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
+#  define BOOST_SYMBOL_EXPORT
+#endif
+//
+// ABI fixing headers:
+//
+#if __BORLANDC__ != 0x600 // not implemented for version 6 compiler yet
+#ifndef BOOST_ABI_PREFIX
+#  define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp"
+#endif
+#ifndef BOOST_ABI_SUFFIX
+#  define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp"
+#endif
+#endif
+//
+// Disable Win32 support in ANSI mode:
+//
+#if __BORLANDC__ < 0x600
+#  pragma defineonoption BOOST_DISABLE_WIN32 -A
+#elif defined(__STRICT_ANSI__)
+#  define BOOST_DISABLE_WIN32
+#endif
+//
+// MSVC compatibility mode does some nasty things:
+// TODO: look up if this doesn't apply to the whole 12xx range
+//
+#if defined(_MSC_VER) && (_MSC_VER <= 1200)
+#  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#  define BOOST_NO_VOID_RETURNS
+#endif
+
+// Borland did not implement value-initialization completely, as I reported
+// in 2007, Borland Report 51854, "Value-initialization: POD struct should be
+// zero-initialized", http://qc.embarcadero.com/wc/qcmain.aspx?d=51854
+// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
+// (Niels Dekker, LKEB, April 2010)
+#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+
+#define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__)
diff --git a/libktorrent/miniboost/boost/config/compiler/clang.hpp b/libktorrent/miniboost/boost/config/compiler/clang.hpp
new file mode 100644
index 00000000..6a178242
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/clang.hpp
@@ -0,0 +1,200 @@
+// (C) Copyright Douglas Gregor 2010
+//
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+// Clang compiler setup.
+
+#define BOOST_HAS_PRAGMA_ONCE
+
+// When compiling with clang before __has_extension was defined,
+// even if one writes 'defined(__has_extension) && __has_extension(xxx)',
+// clang reports a compiler error. So the only workaround found is:
+
+#ifndef __has_extension
+#define __has_extension __has_feature
+#endif
+
+#if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+
+#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_RTTI)
+#  define BOOST_NO_RTTI
+#endif
+
+#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_TYPEID)
+#  define BOOST_NO_TYPEID
+#endif
+
+#if defined(__int64) && !defined(__GNUC__)
+#  define BOOST_HAS_MS_INT64
+#endif
+
+#define BOOST_HAS_NRVO
+
+// Branch prediction hints
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_expect)
+#define BOOST_LIKELY(x) __builtin_expect(x, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
+#endif
+#endif
+
+// Clang supports "long long" in all compilation modes.
+#define BOOST_HAS_LONG_LONG
+
+#if defined(__SIZEOF_INT128__)
+#  define BOOST_HAS_INT128
+#endif
+
+
+//
+// Dynamic shared object (DSO) and dynamic-link library (DLL) support
+//
+#if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
+#  define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
+#  define BOOST_SYMBOL_IMPORT
+#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
+#endif
+
+//
+// The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through
+// between switch labels.
+//
+#if __cplusplus >= 201103L && defined(__has_warning)
+#  if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#    define BOOST_FALLTHROUGH [[clang::fallthrough]]
+#  endif
+#endif
+
+#if !__has_feature(cxx_auto_type)
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#endif
+
+//
+// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t
+//
+#if defined(_MSC_VER) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#endif
+
+#if !__has_feature(cxx_constexpr)
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
+
+#if !__has_feature(cxx_decltype)
+#  define BOOST_NO_CXX11_DECLTYPE
+#endif
+
+#if !__has_feature(cxx_decltype_incomplete_return_types)
+#  define BOOST_NO_CXX11_DECLTYPE_N3276
+#endif
+
+#if !__has_feature(cxx_defaulted_functions)
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#endif
+
+#if !__has_feature(cxx_deleted_functions)
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#endif
+
+#if !__has_feature(cxx_explicit_conversions)
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#endif
+
+#if !__has_feature(cxx_default_function_template_args)
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+
+#if !__has_feature(cxx_generalized_initializers)
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#endif
+
+#if !__has_feature(cxx_lambdas)
+#  define BOOST_NO_CXX11_LAMBDAS
+#endif
+
+#if !__has_feature(cxx_local_type_template_args)
+#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#endif
+
+#if !__has_feature(cxx_noexcept)
+#  define BOOST_NO_CXX11_NOEXCEPT
+#endif
+
+#if !__has_feature(cxx_nullptr)
+#  define BOOST_NO_CXX11_NULLPTR
+#endif
+
+#if !__has_feature(cxx_range_for)
+#  define BOOST_NO_CXX11_RANGE_BASED_FOR
+#endif
+
+#if !__has_feature(cxx_raw_string_literals)
+#  define BOOST_NO_CXX11_RAW_LITERALS
+#endif
+
+#if !__has_feature(cxx_reference_qualified_functions)
+#  define BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+
+#if !__has_feature(cxx_generalized_initializers)
+#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#endif
+
+#if !__has_feature(cxx_rvalue_references)
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+
+#if !__has_feature(cxx_strong_enums)
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+
+#if !__has_feature(cxx_static_assert)
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#endif
+
+#if !__has_feature(cxx_alias_templates)
+#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#endif
+
+#if !__has_feature(cxx_unicode_literals)
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+
+#if !__has_feature(cxx_variadic_templates)
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif
+
+#if !__has_feature(cxx_user_literals)
+#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#endif
+
+#if !(__has_feature(cxx_alignas) || __has_extension(cxx_alignas))
+#  define BOOST_NO_CXX11_ALIGNAS
+#endif
+
+#if !__has_feature(cxx_trailing_return)
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#endif
+
+#if !__has_feature(cxx_inline_namespaces)
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#endif
+
+// Clang always supports variadic macros
+// Clang always supports extern templates
+
+#ifndef BOOST_COMPILER
+#  define BOOST_COMPILER "Clang version " __clang_version__
+#endif
+
+// Macro used to identify the Clang compiler.
+#define BOOST_CLANG 1
+
diff --git a/libktorrent/miniboost/boost/config/compiler/codegear.hpp b/libktorrent/miniboost/boost/config/compiler/codegear.hpp
new file mode 100644
index 00000000..6b52282f
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/codegear.hpp
@@ -0,0 +1,190 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Aleksey Gurtovoy 2002.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  CodeGear C++ compiler setup:
+
+#if !defined( BOOST_WITH_CODEGEAR_WARNINGS )
+// these warnings occur frequently in optimized template code
+# pragma warn -8004 // var assigned value, but never used
+# pragma warn -8008 // condition always true/false
+# pragma warn -8066 // dead code can never execute
+# pragma warn -8104 // static members with ctors not threadsafe
+# pragma warn -8105 // reference member in class without ctors
+#endif
+//
+// versions check:
+// last known and checked version is 0x621
+#if (__CODEGEARC__ > 0x621)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  else
+#     pragma message( "Unknown compiler version - please run the configure tests and report the results")
+#  endif
+#endif
+
+// CodeGear C++ Builder 2009
+#if (__CODEGEARC__ <= 0x613)
+#  define BOOST_NO_INTEGRAL_INT64_T
+#  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
+#  define BOOST_NO_PRIVATE_IN_AGGREGATE
+#  define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+   // we shouldn't really need this - but too many things choke
+   // without it, this needs more investigation:
+#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#  define BOOST_SP_NO_SP_CONVERTIBLE
+#endif
+
+// CodeGear C++ Builder 2010
+#if (__CODEGEARC__ <= 0x621)
+#  define BOOST_NO_TYPENAME_WITH_CTOR    // Cannot use typename keyword when making temporaries of a dependant type
+#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#  define BOOST_NO_NESTED_FRIENDSHIP     // TC1 gives nested classes access rights as any other member
+#  define BOOST_NO_USING_TEMPLATE
+#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+// Temporary hack, until specific MPL preprocessed headers are generated
+#  define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+// CodeGear has not yet completely implemented value-initialization, for
+// example for array types, as I reported in 2010: Embarcadero Report 83751,
+// "Value-initialization: arrays should have each element value-initialized",
+// http://qc.embarcadero.com/wc/qcmain.aspx?d=83751
+// Last checked version: Embarcadero C++ 6.21
+// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
+// (Niels Dekker, LKEB, April 2010)
+#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+
+#  if defined(NDEBUG) && defined(__cplusplus)
+      // fix broken  so that Boost.test works:
+#     include 
+#     undef strcmp
+#  endif
+   // fix broken errno declaration:
+#  include 
+#  ifndef errno
+#     define errno errno
+#  endif
+
+#endif
+
+// Reportedly, #pragma once is supported since C++ Builder 2010
+#if (__CODEGEARC__ >= 0x620)
+#  define BOOST_HAS_PRAGMA_ONCE
+#endif
+
+//
+// C++0x macros:
+//
+#if (__CODEGEARC__ <= 0x620)
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#else
+#define BOOST_HAS_STATIC_ASSERT
+#endif
+#define BOOST_HAS_CHAR16_T
+#define BOOST_HAS_CHAR32_T
+#define BOOST_HAS_LONG_LONG
+// #define BOOST_HAS_ALIGNOF
+#define BOOST_HAS_DECLTYPE
+#define BOOST_HAS_EXPLICIT_CONVERSION_OPS
+// #define BOOST_HAS_RVALUE_REFS
+#define BOOST_HAS_SCOPED_ENUM
+// #define BOOST_HAS_STATIC_ASSERT
+#define BOOST_HAS_STD_TYPE_TRAITS
+
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+//
+// TR1 macros:
+//
+#define BOOST_HAS_TR1_HASH
+#define BOOST_HAS_TR1_TYPE_TRAITS
+#define BOOST_HAS_TR1_UNORDERED_MAP
+#define BOOST_HAS_TR1_UNORDERED_SET
+
+#define BOOST_HAS_MACRO_USE_FACET
+
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+// On non-Win32 platforms let the platform config figure this out:
+#ifdef _WIN32
+#  define BOOST_HAS_STDINT_H
+#endif
+
+//
+// __int64:
+//
+#if !defined(__STRICT_ANSI__)
+#  define BOOST_HAS_MS_INT64
+#endif
+//
+// check for exception handling support:
+//
+#if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+//
+// all versions have a :
+//
+#if !defined(__STRICT_ANSI__)
+#  define BOOST_HAS_DIRENT_H
+#endif
+//
+// all versions support __declspec:
+//
+#if defined(__STRICT_ANSI__)
+// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
+#  define BOOST_SYMBOL_EXPORT
+#endif
+//
+// ABI fixing headers:
+//
+#ifndef BOOST_ABI_PREFIX
+#  define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp"
+#endif
+#ifndef BOOST_ABI_SUFFIX
+#  define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp"
+#endif
+//
+// Disable Win32 support in ANSI mode:
+//
+#  pragma defineonoption BOOST_DISABLE_WIN32 -A
+//
+// MSVC compatibility mode does some nasty things:
+// TODO: look up if this doesn't apply to the whole 12xx range
+//
+#if defined(_MSC_VER) && (_MSC_VER <= 1200)
+#  define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#  define BOOST_NO_VOID_RETURNS
+#endif
+
+#define BOOST_COMPILER "CodeGear C++ version " BOOST_STRINGIZE(__CODEGEARC__)
+
diff --git a/libktorrent/miniboost/boost/config/compiler/comeau.hpp b/libktorrent/miniboost/boost/config/compiler/comeau.hpp
new file mode 100644
index 00000000..278222dc
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/comeau.hpp
@@ -0,0 +1,59 @@
+//  (C) Copyright John Maddock 2001. 
+//  (C) Copyright Douglas Gregor 2001. 
+//  (C) Copyright Peter Dimov 2001. 
+//  (C) Copyright Aleksey Gurtovoy 2003. 
+//  (C) Copyright Beman Dawes 2003. 
+//  (C) Copyright Jens Maurer 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Comeau C++ compiler setup:
+
+#include "boost/config/compiler/common_edg.hpp"
+
+#if (__COMO_VERSION__ <= 4245)
+
+#  if defined(_MSC_VER) && _MSC_VER <= 1300
+#     if _MSC_VER > 100
+         // only set this in non-strict mode:
+#        define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#     endif
+#  endif
+
+// Void returns don't work when emulating VC 6 (Peter Dimov)
+// TODO: look up if this doesn't apply to the whole 12xx range
+#  if defined(_MSC_VER) && (_MSC_VER < 1300)
+#     define BOOST_NO_VOID_RETURNS
+#  endif
+
+#endif  // version 4245
+
+//
+// enable __int64 support in VC emulation mode
+//
+#  if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#     define BOOST_HAS_MS_INT64
+#  endif
+
+#define BOOST_COMPILER "Comeau compiler version " BOOST_STRINGIZE(__COMO_VERSION__)
+
+//
+// versions check:
+// we don't know Comeau prior to version 4245:
+#if __COMO_VERSION__ < 4245
+#  error "Compiler not configured - please reconfigure"
+#endif
+//
+// last known and checked version is 4245:
+#if (__COMO_VERSION__ > 4245)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/common_edg.hpp b/libktorrent/miniboost/boost/config/compiler/common_edg.hpp
new file mode 100644
index 00000000..d5589add
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/common_edg.hpp
@@ -0,0 +1,113 @@
+//  (C) Copyright John Maddock 2001 - 2002.
+//  (C) Copyright Jens Maurer 2001.
+//  (C) Copyright David Abrahams 2002.
+//  (C) Copyright Aleksey Gurtovoy 2002.
+//  (C) Copyright Markus Schoepflin 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//
+// Options common to all edg based compilers.
+//
+// This is included from within the individual compiler mini-configs.
+
+#ifndef  __EDG_VERSION__
+#  error This file requires that __EDG_VERSION__ be defined.
+#endif
+
+#if (__EDG_VERSION__ <= 238)
+#   define BOOST_NO_INTEGRAL_INT64_T
+#   define BOOST_NO_SFINAE
+#endif
+
+#if (__EDG_VERSION__ <= 240)
+#   define BOOST_NO_VOID_RETURNS
+#endif
+
+#if (__EDG_VERSION__ <= 241) && !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+#   define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#endif
+
+#if (__EDG_VERSION__ <= 244) && !defined(BOOST_NO_TEMPLATE_TEMPLATES)
+#   define BOOST_NO_TEMPLATE_TEMPLATES
+#endif
+
+#if (__EDG_VERSION__ < 300) && !defined(BOOST_NO_IS_ABSTRACT)
+#   define BOOST_NO_IS_ABSTRACT
+#endif
+
+#if (__EDG_VERSION__ <= 303) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+#   define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#endif
+
+// See also kai.hpp which checks a Kai-specific symbol for EH
+# if !defined(__KCC) && !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
+#     define BOOST_NO_EXCEPTIONS
+# endif
+
+# if !defined(__NO_LONG_LONG)
+#     define BOOST_HAS_LONG_LONG
+# else
+#     define BOOST_NO_LONG_LONG
+# endif
+
+// Not sure what version was the first to support #pragma once, but
+// different EDG-based compilers (e.g. Intel) supported it for ages.
+// Add a proper version check if it causes problems.
+#define BOOST_HAS_PRAGMA_ONCE
+
+//
+// C++0x features
+//
+//   See above for BOOST_NO_LONG_LONG
+//
+#if (__EDG_VERSION__ < 310)
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#endif
+#if (__EDG_VERSION__ <= 310)
+// No support for initializer lists
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#endif
+#if (__EDG_VERSION__ < 400)
+#  define BOOST_NO_CXX11_VARIADIC_MACROS
+#endif
+
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+#ifdef c_plusplus
+// EDG has "long long" in non-strict mode
+// However, some libraries have insufficient "long long" support
+// #define BOOST_HAS_LONG_LONG
+#endif
diff --git a/libktorrent/miniboost/boost/config/compiler/compaq_cxx.hpp b/libktorrent/miniboost/boost/config/compiler/compaq_cxx.hpp
new file mode 100644
index 00000000..b44486c6
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/compaq_cxx.hpp
@@ -0,0 +1,19 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Tru64 C++ compiler setup (now HP):
+
+#define BOOST_COMPILER "HP Tru64 C++ " BOOST_STRINGIZE(__DECCXX_VER)
+
+#include "boost/config/compiler/common_edg.hpp"
+
+//
+// versions check:
+// Nothing to do here?
+
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/cray.hpp b/libktorrent/miniboost/boost/config/compiler/cray.hpp
new file mode 100644
index 00000000..94e932b8
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/cray.hpp
@@ -0,0 +1,89 @@
+//  (C) Copyright John Maddock 2011.
+//  (C) Copyright Cray, Inc. 2013
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Greenhills C compiler setup:
+
+#define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE)
+
+#if _RELEASE < 8
+#  error "Boost is not configured for Cray compilers prior to version 8, please try the configure script."
+#endif
+
+//
+// Check this is a recent EDG based compiler, otherwise we don't support it here:
+//
+#ifndef __EDG_VERSION__
+#  error "Unsupported Cray compiler, please try running the configure script."
+#endif
+
+#include "boost/config/compiler/common_edg.hpp"
+
+
+//
+//
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_HAS_NRVO
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_HAS_NRVO
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+//#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
+#define BOOST_MATH_DISABLE_STD_FPCLASSIFY
+//#define BOOST_HAS_FPCLASSIFY
+
+#define BOOST_SP_USE_PTHREADS 
+#define BOOST_AC_USE_PTHREADS 
+
+/* everything that follows is working around what are thought to be
+ * compiler shortcomings.  Revist all of these regularly.
+ */
+
+//#define BOOST_USE_ENUM_STATIC_ASSERT
+//#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS //(this may be implied by the previous #define
+
+// These constants should be provided by the 
+// compiler, at least when -hgnu is asserted on the command line.
+
+#ifndef __ATOMIC_RELAXED
+#define __ATOMIC_RELAXED 0
+#define __ATOMIC_CONSUME 1
+#define __ATOMIC_ACQUIRE 2
+#define __ATOMIC_RELEASE 3
+#define __ATOMIC_ACQ_REL 4
+#define __ATOMIC_SEQ_CST 5
+#endif
+
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/digitalmars.hpp b/libktorrent/miniboost/boost/config/compiler/digitalmars.hpp
new file mode 100644
index 00000000..7bc49ab4
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/digitalmars.hpp
@@ -0,0 +1,94 @@
+//  Copyright (C) Christof Meerwald 2003
+//  Copyright (C) Dan Watkins 2003
+//
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  Digital Mars C++ compiler setup:
+#define BOOST_COMPILER __DMC_VERSION_STRING__
+
+#define BOOST_HAS_LONG_LONG
+#define BOOST_HAS_PRAGMA_ONCE
+
+#if !defined(BOOST_STRICT_CONFIG)
+#define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#define BOOST_NO_OPERATORS_IN_NAMESPACE
+#define BOOST_NO_UNREACHABLE_RETURN_DETECTION
+#define BOOST_NO_SFINAE
+#define BOOST_NO_USING_TEMPLATE
+#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#endif
+
+//
+// has macros:
+#define BOOST_HAS_DIRENT_H
+#define BOOST_HAS_STDINT_H
+#define BOOST_HAS_WINTHREADS
+
+#if (__DMC__ >= 0x847)
+#define BOOST_HAS_EXPM1
+#define BOOST_HAS_LOG1P
+#endif
+
+//
+// Is this really the best way to detect whether the std lib is in namespace std?
+//
+#ifdef __cplusplus
+#include 
+#endif
+#if !defined(__STL_IMPORT_VENDOR_CSTD) && !defined(_STLP_IMPORT_VENDOR_CSTD)
+#  define BOOST_NO_STDC_NAMESPACE
+#endif
+
+
+// check for exception handling support:
+#if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+
+//
+// C++0x features
+//
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+#if (__DMC__ <= 0x840)
+#error "Compiler not supported or configured - please reconfigure"
+#endif
+//
+// last known and checked version is ...:
+#if (__DMC__ > 0x848)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
diff --git a/libktorrent/miniboost/boost/config/compiler/gcc.hpp b/libktorrent/miniboost/boost/config/compiler/gcc.hpp
new file mode 100644
index 00000000..ef6b07e2
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/gcc.hpp
@@ -0,0 +1,266 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright Darin Adler 2001 - 2002.
+//  (C) Copyright Jens Maurer 2001 - 2002.
+//  (C) Copyright Beman Dawes 2001 - 2003.
+//  (C) Copyright Douglas Gregor 2002.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Synge Todo 2003.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  GNU C++ compiler setup.
+
+//
+// Define BOOST_GCC so we know this is "real" GCC and not some pretender:
+//
+#if !defined(__CUDACC__)
+#define BOOST_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif
+
+#if __GNUC__ == 3
+#  if defined (__PATHSCALE__)
+#     define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#     define BOOST_NO_IS_ABSTRACT
+#  endif
+
+#  if __GNUC_MINOR__ < 4
+#     define BOOST_NO_IS_ABSTRACT
+#  endif
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#endif
+#if __GNUC__ < 4
+//
+// All problems to gcc-3.x and earlier here:
+//
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#  ifdef __OPEN64__
+#     define BOOST_NO_IS_ABSTRACT
+#  endif
+#endif
+
+// GCC prior to 3.4 had #pragma once too but it didn't work well with filesystem links
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#define BOOST_HAS_PRAGMA_ONCE
+#endif
+
+#if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+// Previous versions of GCC did not completely implement value-initialization:
+// GCC Bug 30111, "Value-initialization of POD base class doesn't initialize
+// members", reported by Jonathan Wakely in 2006,
+// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111 (fixed for GCC 4.4)
+// GCC Bug 33916, "Default constructor fails to initialize array members",
+// reported by Michael Elizabeth Chastain in 2007,
+// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916 (fixed for GCC 4.2.4)
+// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
+#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+#endif
+
+#if !defined(__EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
+# define BOOST_NO_EXCEPTIONS
+#endif
+
+
+//
+// Threading support: Turn this on unconditionally here (except for
+// those platforms where we can know for sure). It will get turned off again
+// later if no threading API is detected.
+//
+#if !defined(__MINGW32__) && !defined(linux) && !defined(__linux) && !defined(__linux__)
+# define BOOST_HAS_THREADS
+#endif
+
+//
+// gcc has "long long"
+// Except on Darwin with standard compliance enabled (-pedantic)
+// Apple gcc helpfully defines this macro we can query
+//
+#if !defined(__DARWIN_NO_LONG_LONG)
+# define BOOST_HAS_LONG_LONG
+#endif
+
+//
+// gcc implements the named return value optimization since version 3.1
+//
+#define BOOST_HAS_NRVO
+
+// Branch prediction hints
+#define BOOST_LIKELY(x) __builtin_expect(x, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
+
+//
+// Dynamic shared object (DSO) and dynamic-link library (DLL) support
+//
+#if __GNUC__ >= 4
+#  if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(__CYGWIN__)
+     // All Win32 development environments, including 64-bit Windows and MinGW, define
+     // _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
+     // so does not define _WIN32 or its variants.
+#    define BOOST_HAS_DECLSPEC
+#    define BOOST_SYMBOL_EXPORT __attribute__((__dllexport__))
+#    define BOOST_SYMBOL_IMPORT __attribute__((__dllimport__))
+#  else
+#    define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
+#    define BOOST_SYMBOL_IMPORT
+#  endif
+#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
+#else
+// config/platform/win32.hpp will define BOOST_SYMBOL_EXPORT, etc., unless already defined
+#  define BOOST_SYMBOL_EXPORT
+#endif
+
+//
+// RTTI and typeinfo detection is possible post gcc-4.3:
+//
+#if __GNUC__ * 100 + __GNUC_MINOR__ >= 403
+#  ifndef __GXX_RTTI
+#     ifndef BOOST_NO_TYPEID
+#        define BOOST_NO_TYPEID
+#     endif
+#     ifndef BOOST_NO_RTTI
+#        define BOOST_NO_RTTI
+#     endif
+#  endif
+#endif
+
+//
+// Recent GCC versions have __int128 when in 64-bit mode.
+//
+// We disable this if the compiler is really nvcc as it
+// doesn't actually support __int128 as of CUDA_VERSION=5000
+// even though it defines __SIZEOF_INT128__.
+// See https://svn.boost.org/trac/boost/ticket/8048
+// Only re-enable this for nvcc if you're absolutely sure
+// of the circumstances under which it's supported:
+//
+#if defined(__SIZEOF_INT128__) && !defined(__CUDACC__)
+#  define BOOST_HAS_INT128
+#endif
+
+// C++0x features in 4.3.n and later
+//
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && defined(__GXX_EXPERIMENTAL_CXX0X__)
+// C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
+// passed on the command line, which in turn defines
+// __GXX_EXPERIMENTAL_CXX0X__.
+#  define BOOST_HAS_DECLTYPE
+#  define BOOST_HAS_RVALUE_REFS
+#  define BOOST_HAS_STATIC_ASSERT
+#  define BOOST_HAS_VARIADIC_TMPL
+#else
+#  define BOOST_NO_CXX11_DECLTYPE
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+
+// Variadic templates compiler:
+//   http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html
+#  if defined(__VARIADIC_TEMPLATES) || (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4) && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#    define BOOST_HAS_VARIADIC_TMPL
+#  else
+#    define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  endif
+#endif
+
+// C++0x features in 4.4.n and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#endif
+
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+#  define BOOST_NO_SFINAE_EXPR
+#endif
+
+// GCC 4.5 forbids declaration of defaulted functions in private or protected sections
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
+#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+#endif
+
+// C++0x features in 4.5.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_LAMBDAS
+#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#  define BOOST_NO_CXX11_RAW_LITERALS
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+
+// C++0x features in 4.5.1 and later
+//
+#if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40501) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+// scoped enums have a serious bug in 4.4.0, so define BOOST_NO_CXX11_SCOPED_ENUMS before 4.5.1
+// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38064
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+
+// C++0x features in 4.6.n and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#endif
+
+// C++0x features in 4.7.n and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#endif
+
+// C++0x features in 4.8.n and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_ALIGNAS
+#endif
+
+// C++0x features in 4.8.1 and later
+//
+#if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40801) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_DECLTYPE_N3276
+#  define BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+
+#ifndef BOOST_COMPILER
+#  define BOOST_COMPILER "GNU C++ version " __VERSION__
+#endif
+
+// ConceptGCC compiler:
+//   http://www.generic-programming.org/software/ConceptGCC/
+#ifdef __GXX_CONCEPTS__
+#  define BOOST_HAS_CONCEPTS
+#  define BOOST_COMPILER "ConceptGCC version " __VERSION__
+#endif
+
+// versions check:
+// we don't know gcc prior to version 3.30:
+#if (__GNUC__ < 3) || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3))
+#  error "Compiler not configured - please reconfigure"
+#endif
+//
+// last known and checked version is 4.6 (Pre-release):
+#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  else
+// we don't emit warnings here anymore since there are no defect macros defined for
+// gcc post 3.4, so any failures are gcc regressions...
+//#     warning "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/gcc_xml.hpp b/libktorrent/miniboost/boost/config/compiler/gcc_xml.hpp
new file mode 100644
index 00000000..f04af061
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/gcc_xml.hpp
@@ -0,0 +1,65 @@
+//  (C) Copyright John Maddock 2006.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  GCC-XML C++ compiler setup:
+
+#  if !defined(__GCCXML_GNUC__) || ((__GCCXML_GNUC__ <= 3) && (__GCCXML_GNUC_MINOR__ <= 3))
+#     define BOOST_NO_IS_ABSTRACT
+#  endif
+
+//
+// Threading support: Turn this on unconditionally here (except for
+// those platforms where we can know for sure). It will get turned off again
+// later if no threading API is detected.
+//
+#if !defined(__MINGW32__) && !defined(_MSC_VER) && !defined(linux) && !defined(__linux) && !defined(__linux__)
+# define BOOST_HAS_THREADS
+#endif
+
+//
+// gcc has "long long"
+//
+#define BOOST_HAS_LONG_LONG
+
+// C++0x features:
+//
+#  define BOOST_NO_CXX11_CONSTEXPR
+#  define BOOST_NO_CXX11_NULLPTR
+#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#  define BOOST_NO_CXX11_DECLTYPE
+#  define BOOST_NO_CXX11_DECLTYPE_N3276
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  define BOOST_NO_CXX11_VARIADIC_MACROS
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#  define BOOST_NO_SFINAE_EXPR
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_LAMBDAS
+#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#  define BOOST_NO_CXX11_RANGE_BASED_FOR
+#  define BOOST_NO_CXX11_RAW_LITERALS
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#  define BOOST_NO_CXX11_NOEXCEPT
+#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#  define BOOST_NO_CXX11_ALIGNAS
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#  define BOOST_NO_CXX11_REF_QUALIFIERS
+
+#define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/greenhills.hpp b/libktorrent/miniboost/boost/config/compiler/greenhills.hpp
new file mode 100644
index 00000000..038b6b2b
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/greenhills.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Greenhills C++ compiler setup:
+
+#define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs)
+
+#include "boost/config/compiler/common_edg.hpp"
+
+//
+// versions check:
+// we don't support Greenhills prior to version 0:
+#if __ghs < 0
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+//
+// last known and checked version is 0:
+#if (__ghs > 0)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/hp_acc.hpp b/libktorrent/miniboost/boost/config/compiler/hp_acc.hpp
new file mode 100644
index 00000000..fb63839a
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/hp_acc.hpp
@@ -0,0 +1,145 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright Jens Maurer 2001 - 2003.
+//  (C) Copyright Aleksey Gurtovoy 2002.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Toon Knapen 2003.
+//  (C) Copyright Boris Gubenko 2006 - 2007.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  HP aCC C++ compiler setup:
+
+#if defined(__EDG__)
+#include "boost/config/compiler/common_edg.hpp"
+#endif
+
+#if (__HP_aCC <= 33100)
+#    define BOOST_NO_INTEGRAL_INT64_T
+#    define BOOST_NO_OPERATORS_IN_NAMESPACE
+#  if !defined(_NAMESPACE_STD)
+#     define BOOST_NO_STD_LOCALE
+#     define BOOST_NO_STRINGSTREAM
+#  endif
+#endif
+
+#if (__HP_aCC <= 33300)
+// member templates are sufficiently broken that we disable them for now
+#    define BOOST_NO_MEMBER_TEMPLATES
+#    define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
+#    define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+#endif
+
+#if (__HP_aCC <= 38000)
+#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
+
+#if (__HP_aCC > 50000) && (__HP_aCC < 60000)
+#    define BOOST_NO_UNREACHABLE_RETURN_DETECTION
+#    define BOOST_NO_TEMPLATE_TEMPLATES
+#    define BOOST_NO_SWPRINTF
+#    define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
+#    define BOOST_NO_IS_ABSTRACT
+#    define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#endif
+
+// optional features rather than defects:
+#if (__HP_aCC >= 33900)
+#    define BOOST_HAS_LONG_LONG
+#    define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+#endif
+
+#if (__HP_aCC >= 50000 ) && (__HP_aCC <= 53800 ) || (__HP_aCC < 31300 )
+#    define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
+#endif
+
+// This macro should not be defined when compiling in strict ansi
+// mode, but, currently, we don't have the ability to determine
+// what standard mode we are compiling with. Some future version
+// of aCC6 compiler will provide predefined macros reflecting the
+// compilation options, including the standard mode.
+#if (__HP_aCC >= 60000) || ((__HP_aCC > 38000) && defined(__hpxstd98))
+#    define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
+
+#define BOOST_COMPILER "HP aCC version " BOOST_STRINGIZE(__HP_aCC)
+
+//
+// versions check:
+// we don't support HP aCC prior to version 33000:
+#if __HP_aCC < 33000
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+
+//
+// Extended checks for supporting aCC on PA-RISC
+#if __HP_aCC > 30000 && __HP_aCC < 50000
+#  if __HP_aCC < 38000
+      // versions prior to version A.03.80 not supported
+#     error "Compiler version not supported - version A.03.80 or higher is required"
+#  elif !defined(__hpxstd98)
+      // must compile using the option +hpxstd98 with version A.03.80 and above
+#     error "Compiler option '+hpxstd98' is required for proper support"
+#  endif //PA-RISC
+#endif
+
+//
+// C++0x features
+//
+//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#if !defined(__EDG__)
+
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+/*
+  See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
+      https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443436
+*/
+
+#if (__HP_aCC < 62500) || !defined(HP_CXX0x_SOURCE)
+  #define BOOST_NO_CXX11_VARIADIC_MACROS
+#endif
+
+#endif
+
+//
+// last known and checked version for HP-UX/ia64 is 61300
+// last known and checked version for PA-RISC is 38000
+#if ((__HP_aCC > 61300) || ((__HP_aCC > 38000) && defined(__hpxstd98)))
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
diff --git a/libktorrent/miniboost/boost/config/compiler/intel.hpp b/libktorrent/miniboost/boost/config/compiler/intel.hpp
new file mode 100644
index 00000000..cbc9422f
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/intel.hpp
@@ -0,0 +1,324 @@
+//  (C) Copyright John Maddock 2001-8.
+//  (C) Copyright Peter Dimov 2001.
+//  (C) Copyright Jens Maurer 2001.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Aleksey Gurtovoy 2002 - 2003.
+//  (C) Copyright Guillaume Melquiond 2002 - 2003.
+//  (C) Copyright Beman Dawes 2003.
+//  (C) Copyright Martin Wille 2003.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Intel compiler setup:
+
+#include "boost/config/compiler/common_edg.hpp"
+
+#if defined(__INTEL_COMPILER)
+#  define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER
+#elif defined(__ICL)
+#  define BOOST_INTEL_CXX_VERSION __ICL
+#elif defined(__ICC)
+#  define BOOST_INTEL_CXX_VERSION __ICC
+#elif defined(__ECC)
+#  define BOOST_INTEL_CXX_VERSION __ECC
+#endif
+
+// Flags determined by comparing output of 'icpc -dM -E' with and without '-std=c++0x'
+#if (!(defined(_WIN32) || defined(_WIN64)) && defined(__STDC_HOSTED__) && (__STDC_HOSTED__ && (BOOST_INTEL_CXX_VERSION <= 1200))) || defined(__GXX_EXPERIMENTAL_CPP0X__) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_INTEL_STDCXX0X
+#endif
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#  define BOOST_INTEL_STDCXX0X
+#endif
+
+#ifdef BOOST_INTEL_STDCXX0X
+#define BOOST_COMPILER "Intel C++ C++0x mode version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
+#else
+#define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
+#endif
+#define BOOST_INTEL BOOST_INTEL_CXX_VERSION
+
+#if defined(_WIN32) || defined(_WIN64)
+#  define BOOST_INTEL_WIN BOOST_INTEL
+#else
+#  define BOOST_INTEL_LINUX BOOST_INTEL
+#endif
+
+#if (BOOST_INTEL_CXX_VERSION <= 600)
+
+#  if defined(_MSC_VER) && (_MSC_VER <= 1300) // added check for <= VC 7 (Peter Dimov)
+
+// Boost libraries assume strong standard conformance unless otherwise
+// indicated by a config macro. As configured by Intel, the EDG front-end
+// requires certain compiler options be set to achieve that strong conformance.
+// Particularly /Qoption,c,--arg_dep_lookup (reported by Kirk Klobe & Thomas Witt)
+// and /Zc:wchar_t,forScope. See boost-root/tools/build/intel-win32-tools.jam for
+// details as they apply to particular versions of the compiler. When the
+// compiler does not predefine a macro indicating if an option has been set,
+// this config file simply assumes the option has been set.
+// Thus BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP will not be defined, even if
+// the compiler option is not enabled.
+
+#     define BOOST_NO_SWPRINTF
+#  endif
+
+// Void returns, 64 bit integrals don't work when emulating VC 6 (Peter Dimov)
+
+#  if defined(_MSC_VER) && (_MSC_VER <= 1200)
+#     define BOOST_NO_VOID_RETURNS
+#     define BOOST_NO_INTEGRAL_INT64_T
+#  endif
+
+#endif
+
+#if (BOOST_INTEL_CXX_VERSION <= 710) && defined(_WIN32)
+#  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
+#endif
+
+// See http://aspn.activestate.com/ASPN/Mail/Message/boost/1614864
+#if BOOST_INTEL_CXX_VERSION < 600
+#  define BOOST_NO_INTRINSIC_WCHAR_T
+#else
+// We should test the macro _WCHAR_T_DEFINED to check if the compiler
+// supports wchar_t natively. *BUT* there is a problem here: the standard
+// headers define this macro if they typedef wchar_t. Anyway, we're lucky
+// because they define it without a value, while Intel C++ defines it
+// to 1. So we can check its value to see if the macro was defined natively
+// or not.
+// Under UNIX, the situation is exactly the same, but the macro _WCHAR_T
+// is used instead.
+#  if ((_WCHAR_T_DEFINED + 0) == 0) && ((_WCHAR_T + 0) == 0)
+#    define BOOST_NO_INTRINSIC_WCHAR_T
+#  endif
+#endif
+
+#if defined(__GNUC__) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+//
+// Figure out when Intel is emulating this gcc bug
+// (All Intel versions prior to 9.0.26, and versions
+// later than that if they are set up to emulate gcc 3.2
+// or earlier):
+//
+#  if ((__GNUC__ == 3) && (__GNUC_MINOR__ <= 2)) || (BOOST_INTEL < 900) || (__INTEL_COMPILER_BUILD_DATE < 20050912)
+#     define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#  endif
+#endif
+#if (defined(__GNUC__) && (__GNUC__ < 4)) || (defined(_WIN32) && (BOOST_INTEL_CXX_VERSION <= 1200)) || (BOOST_INTEL_CXX_VERSION <= 1200)
+// GCC or VC emulation:
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
+//
+// Verify that we have actually got BOOST_NO_INTRINSIC_WCHAR_T
+// set correctly, if we don't do this now, we will get errors later
+// in type_traits code among other things, getting this correct
+// for the Intel compiler is actually remarkably fragile and tricky:
+//
+#ifdef __cplusplus
+#if defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#include 
+template< typename T > struct assert_no_intrinsic_wchar_t;
+template<> struct assert_no_intrinsic_wchar_t { typedef void type; };
+// if you see an error here then you need to unset BOOST_NO_INTRINSIC_WCHAR_T
+// where it is defined above:
+typedef assert_no_intrinsic_wchar_t::type assert_no_intrinsic_wchar_t_;
+#else
+template< typename T > struct assert_intrinsic_wchar_t;
+template<> struct assert_intrinsic_wchar_t {};
+// if you see an error here then define BOOST_NO_INTRINSIC_WCHAR_T on the command line:
+template<> struct assert_intrinsic_wchar_t {};
+#endif
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER+0 >= 1000)
+#  if _MSC_VER >= 1200
+#     define BOOST_HAS_MS_INT64
+#  endif
+#  define BOOST_NO_SWPRINTF
+#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#elif defined(_WIN32)
+#  define BOOST_DISABLE_WIN32
+#endif
+
+// I checked version 6.0 build 020312Z, it implements the NRVO.
+// Correct this as you find out which version of the compiler
+// implemented the NRVO first.  (Daniel Frey)
+#if (BOOST_INTEL_CXX_VERSION >= 600)
+#  define BOOST_HAS_NRVO
+#endif
+
+// Branch prediction hints
+// I'm not sure 8.0 was the first version to support these builtins,
+// update the condition if the version is not accurate. (Andrey Semashev)
+#if defined(__GNUC__) && BOOST_INTEL_CXX_VERSION >= 800
+#define BOOST_LIKELY(x) __builtin_expect(x, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
+#endif
+
+//
+// versions check:
+// we don't support Intel prior to version 6.0:
+#if BOOST_INTEL_CXX_VERSION < 600
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+
+// Intel on MacOS requires
+#if defined(__APPLE__) && defined(__INTEL_COMPILER)
+#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
+
+// Intel on Altix Itanium
+#if defined(__itanium__) && defined(__INTEL_COMPILER)
+#  define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#endif
+
+//
+// An attempt to value-initialize a pointer-to-member may trigger an
+// internal error on Intel <= 11.1 (last checked version), as was
+// reported by John Maddock, Intel support issue 589832, May 2010.
+// Moreover, according to test results from Huang-Vista-x86_32_intel,
+// intel-vc9-win-11.1 may leave a non-POD array uninitialized, in some
+// cases when it should be value-initialized.
+// (Niels Dekker, LKEB, May 2010)
+// Apparently Intel 12.1 (compiler version number 9999 !!) has the same issue (compiler regression).
+#if defined(__INTEL_COMPILER)
+#  if (__INTEL_COMPILER <= 1110) || (__INTEL_COMPILER == 9999) || (defined(_WIN32) && (__INTEL_COMPILER < 1500))
+#    define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+#  endif
+#endif
+
+//
+// Dynamic shared object (DSO) and dynamic-link library (DLL) support
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#  define BOOST_SYMBOL_EXPORT __attribute__((visibility("default")))
+#  define BOOST_SYMBOL_IMPORT
+#  define BOOST_SYMBOL_VISIBLE __attribute__((visibility("default")))
+#endif
+//
+// C++0x features
+//     - ICC added static_assert in 11.0 (first version with C++0x support)
+//
+#if defined(BOOST_INTEL_STDCXX0X)
+#  undef  BOOST_NO_CXX11_STATIC_ASSERT
+//
+// These pass our test cases, but aren't officially supported according to:
+// http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
+//
+//#  undef  BOOST_NO_CXX11_LAMBDAS
+//#  undef  BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+//#  undef  BOOST_NO_CXX11_DECLTYPE
+//#  undef  BOOST_NO_CXX11_AUTO_DECLARATIONS
+//#  undef  BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#endif
+
+#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1200)
+//#  undef  BOOST_NO_CXX11_RVALUE_REFERENCES // Enabling this breaks Filesystem and Exception libraries
+//#  undef  BOOST_NO_CXX11_SCOPED_ENUMS  // doesn't really work!!
+#  undef  BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  undef  BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  undef  BOOST_NO_CXX11_LAMBDAS
+#  undef  BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#  undef  BOOST_NO_CXX11_DECLTYPE
+#  undef  BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  undef  BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  undef  BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#endif
+
+// icl Version 12.1.0.233 Build 20110811 and possibly some other builds
+// had an incorrect __INTEL_COMPILER value of 9999. Intel say this has been fixed.
+#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION > 1200)
+#  undef  BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#  undef  BOOST_NO_CXX11_NULLPTR
+#  undef  BOOST_NO_CXX11_RVALUE_REFERENCES
+#  undef  BOOST_NO_SFINAE_EXPR
+#  undef  BOOST_NO_CXX11_TEMPLATE_ALIASES
+#  undef  BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+// http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
+// continues to list scoped enum support as "Partial"
+//#  undef  BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1310) && !defined(_MSC_VER)
+#  undef BOOST_NO_CXX11_INLINE_NAMESPACES
+#  undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+// This one generates internal compiler errors in multiprecision, disabled for now:
+//#  undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS  
+// This one generates errors when used with conditional exception specifications, for example in multiprecision:
+//#  undef BOOST_NO_CXX11_NOEXCEPT
+#  undef BOOST_NO_CXX11_RANGE_BASED_FOR
+#  undef BOOST_NO_CXX11_SCOPED_ENUMS
+#  undef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#endif
+#if (BOOST_INTEL_CXX_VERSION >= 1310)
+#  undef  BOOST_NO_SFINAE_EXPR
+#endif
+#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1400) && !defined(_MSC_VER)
+#  undef BOOST_NO_CXX11_UNICODE_LITERALS 
+#  undef BOOST_NO_CXX11_RAW_LITERALS 
+// This one generates errors when used with conditional exception specifications, for example in multiprecision:
+//#  undef BOOST_NO_CXX11_NOEXCEPT 
+// This breaks multiprecision:
+//#  undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS 
+#  undef BOOST_NO_CXX11_HDR_THREAD 
+#  undef BOOST_NO_CXX11_CHAR32_T 
+#  undef BOOST_NO_CXX11_CHAR16_T
+#  undef BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+
+#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION <= 1310)
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#endif
+
+#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION == 1400)
+// A regression in Intel's compiler means that  seems to be broken in this release as well as  :
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1700)
+//
+// Although the Intel compiler is capable of supporting these, it appears not to in MSVC compatibility mode:
+//
+#  define  BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define  BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  define  BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define  BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define  BOOST_NO_CXX11_TEMPLATE_ALIASES
+#  if(BOOST_INTEL_CXX_VERSION < 1310)
+#     define  BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#  endif
+#endif
+
+#if (BOOST_INTEL_CXX_VERSION < 1200)
+//
+// fenv.h appears not to work with Intel prior to 12.0:
+//
+#  define BOOST_NO_FENV_H
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#  define BOOST_HAS_STDINT_H
+#endif
+
+#if defined(__LP64__) && defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1310)
+#  define BOOST_HAS_INT128
+#endif
+
+//
+// last known and checked version:
+#if (BOOST_INTEL_CXX_VERSION > 1310)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  elif defined(_MSC_VER)
+//
+//      We don't emit this warning any more, since we have so few
+//      defect macros set anyway (just the one).
+//
+//#     pragma message("Unknown compiler version - please run the configure tests and report the results")
+#  endif
+#endif
+
diff --git a/libktorrent/miniboost/boost/config/compiler/kai.hpp b/libktorrent/miniboost/boost/config/compiler/kai.hpp
new file mode 100644
index 00000000..2337e6a8
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/kai.hpp
@@ -0,0 +1,33 @@
+//  (C) Copyright John Maddock 2001. 
+//  (C) Copyright David Abrahams 2002. 
+//  (C) Copyright Aleksey Gurtovoy 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Kai C++ compiler setup:
+
+#include "boost/config/compiler/common_edg.hpp"
+
+#   if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG)
+      // at least on Sun, the contents of  is not in namespace std
+#     define BOOST_NO_STDC_NAMESPACE
+#   endif
+
+// see also common_edg.hpp which needs a special check for __KCC
+# if !defined(_EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS)
+#     define BOOST_NO_EXCEPTIONS
+# endif
+
+//
+// last known and checked version is 4001:
+#if (__KCC_VERSION > 4001)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/metrowerks.hpp b/libktorrent/miniboost/boost/config/compiler/metrowerks.hpp
new file mode 100644
index 00000000..c000215b
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/metrowerks.hpp
@@ -0,0 +1,149 @@
+//  (C) Copyright John Maddock 2001.
+//  (C) Copyright Darin Adler 2001.
+//  (C) Copyright Peter Dimov 2001.
+//  (C) Copyright David Abrahams 2001 - 2002.
+//  (C) Copyright Beman Dawes 2001 - 2003.
+//  (C) Copyright Stefan Slapeta 2004.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Metrowerks C++ compiler setup:
+
+// locale support is disabled when linking with the dynamic runtime
+#   ifdef _MSL_NO_LOCALE
+#     define BOOST_NO_STD_LOCALE
+#   endif
+
+#   if __MWERKS__ <= 0x2301  // 5.3
+#     define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#     define BOOST_NO_POINTER_TO_MEMBER_CONST
+#     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
+#     define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
+#   endif
+
+#   if __MWERKS__ <= 0x2401  // 6.2
+//#     define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#   endif
+
+#   if(__MWERKS__ <= 0x2407)  // 7.x
+#     define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
+#     define BOOST_NO_UNREACHABLE_RETURN_DETECTION
+#   endif
+
+#   if(__MWERKS__ <= 0x3003)  // 8.x
+#     define BOOST_NO_SFINAE
+#    endif
+
+// the "|| !defined(BOOST_STRICT_CONFIG)" part should apply to the last
+// tested version *only*:
+#   if(__MWERKS__ <= 0x3207) || !defined(BOOST_STRICT_CONFIG) // 9.6
+#     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#     define BOOST_NO_IS_ABSTRACT
+#    endif
+
+#if !__option(wchar_type)
+#   define BOOST_NO_INTRINSIC_WCHAR_T
+#endif
+
+#if !__option(exceptions) && !defined(BOOST_NO_EXCEPTIONS)
+#   define BOOST_NO_EXCEPTIONS
+#endif
+
+#if (__INTEL__ && _WIN32) || (__POWERPC__ && macintosh)
+#   if __MWERKS__ == 0x3000
+#     define BOOST_COMPILER_VERSION 8.0
+#   elif __MWERKS__ == 0x3001
+#     define BOOST_COMPILER_VERSION 8.1
+#   elif __MWERKS__ == 0x3002
+#     define BOOST_COMPILER_VERSION 8.2
+#   elif __MWERKS__ == 0x3003
+#     define BOOST_COMPILER_VERSION 8.3
+#   elif __MWERKS__ == 0x3200
+#     define BOOST_COMPILER_VERSION 9.0
+#   elif __MWERKS__ == 0x3201
+#     define BOOST_COMPILER_VERSION 9.1
+#   elif __MWERKS__ == 0x3202
+#     define BOOST_COMPILER_VERSION 9.2
+#   elif __MWERKS__ == 0x3204
+#     define BOOST_COMPILER_VERSION 9.3
+#   elif __MWERKS__ == 0x3205
+#     define BOOST_COMPILER_VERSION 9.4
+#   elif __MWERKS__ == 0x3206
+#     define BOOST_COMPILER_VERSION 9.5
+#   elif __MWERKS__ == 0x3207
+#     define BOOST_COMPILER_VERSION 9.6
+#   else
+#     define BOOST_COMPILER_VERSION __MWERKS__
+#   endif
+#else
+#  define BOOST_COMPILER_VERSION __MWERKS__
+#endif
+
+//
+// C++0x features
+//
+//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#if __MWERKS__ > 0x3206 && __option(rvalue_refs)
+#  define BOOST_HAS_RVALUE_REFS
+#else
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
+
+//
+// versions check:
+// we don't support Metrowerks prior to version 5.3:
+#if __MWERKS__ < 0x2301
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+//
+// last known and checked version:
+#if (__MWERKS__ > 0x3205)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/mpw.hpp b/libktorrent/miniboost/boost/config/compiler/mpw.hpp
new file mode 100644
index 00000000..7a4ffa15
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/mpw.hpp
@@ -0,0 +1,90 @@
+//  (C) Copyright John Maddock 2001 - 2002.
+//  (C) Copyright Aleksey Gurtovoy 2002.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  MPW C++ compilers setup:
+
+#   if    defined(__SC__)
+#     define BOOST_COMPILER "MPW SCpp version " BOOST_STRINGIZE(__SC__)
+#   elif defined(__MRC__)
+#     define BOOST_COMPILER "MPW MrCpp version " BOOST_STRINGIZE(__MRC__)
+#   else
+#     error "Using MPW compiler configuration by mistake.  Please update."
+#   endif
+
+//
+// MPW 8.90:
+//
+#if (MPW_CPLUS <= 0x890) || !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_NO_CV_SPECIALIZATIONS
+#  define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
+#  define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
+#  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+#  define BOOST_NO_INTRINSIC_WCHAR_T
+#  define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#  define BOOST_NO_USING_TEMPLATE
+
+#  define BOOST_NO_CWCHAR
+#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+
+#  define BOOST_NO_STD_ALLOCATOR /* actually a bug with const reference overloading */
+
+#endif
+
+//
+// C++0x features
+//
+//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+//
+// versions check:
+// we don't support MPW prior to version 8.9:
+#if MPW_CPLUS < 0x890
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+//
+// last known and checked version is 0x890:
+#if (MPW_CPLUS > 0x890)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/nvcc.hpp b/libktorrent/miniboost/boost/config/compiler/nvcc.hpp
new file mode 100644
index 00000000..bbe81f6e
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/nvcc.hpp
@@ -0,0 +1,16 @@
+//  (C) Copyright Eric Jourdanneau, Joel Falcou 2010
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  NVIDIA CUDA C++ compiler setup
+
+#ifndef BOOST_COMPILER
+#  define BOOST_COMPILER "NVIDIA CUDA C++ Compiler"
+#endif
+
+// NVIDIA Specific support
+// BOOST_GPU_ENABLED : Flag a function or a method as being enabled on the host and device
+#define BOOST_GPU_ENABLED __host__ __device__
diff --git a/libktorrent/miniboost/boost/config/compiler/pathscale.hpp b/libktorrent/miniboost/boost/config/compiler/pathscale.hpp
new file mode 100644
index 00000000..0625d7a1
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/pathscale.hpp
@@ -0,0 +1,84 @@
+//  (C) Copyright Bryce Lelbach 2011
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+// PathScale EKOPath C++ Compiler
+
+#ifndef BOOST_COMPILER
+#  define BOOST_COMPILER "PathScale EKOPath C++ Compiler version " __PATHSCALE__
+#endif
+
+#if __PATHCC__ >= 4
+#  define BOOST_MSVC6_MEMBER_TEMPLATES
+#  define BOOST_HAS_UNISTD_H
+#  define BOOST_HAS_STDINT_H
+#  define BOOST_HAS_SIGACTION
+#  define BOOST_HAS_SCHED_YIELD
+#  define BOOST_HAS_THREADS
+#  define BOOST_HAS_PTHREADS
+#  define BOOST_HAS_PTHREAD_YIELD
+#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+#  define BOOST_HAS_NRVO
+#  define BOOST_HAS_NL_TYPES_H
+#  define BOOST_HAS_NANOSLEEP
+#  define BOOST_HAS_LONG_LONG
+#  define BOOST_HAS_LOG1P
+#  define BOOST_HAS_GETTIMEOFDAY
+#  define BOOST_HAS_EXPM1
+#  define BOOST_HAS_DIRENT_H
+#  define BOOST_HAS_CLOCK_GETTIME
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#  define BOOST_NO_SFINAE_EXPR
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_RANGE_BASED_FOR
+#  define BOOST_NO_CXX11_RAW_LITERALS
+#  define BOOST_NO_CXX11_NULLPTR
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_NOEXCEPT
+#  define BOOST_NO_CXX11_LAMBDAS
+#  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define BOOST_NO_CXX11_DECLTYPE
+#  define BOOST_NO_CXX11_DECLTYPE_N3276
+#  define BOOST_NO_CXX11_CONSTEXPR
+#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+#  define BOOST_NO_CXX11_CHAR32_T
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#  define BOOST_NO_CXX11_ALIGNAS
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#  define BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
diff --git a/libktorrent/miniboost/boost/config/compiler/pgi.hpp b/libktorrent/miniboost/boost/config/compiler/pgi.hpp
new file mode 100644
index 00000000..5cf61fa9
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/pgi.hpp
@@ -0,0 +1,126 @@
+//  (C) Copyright Noel Belcourt 2007.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  PGI C++ compiler setup:
+
+#define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__
+#define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
+
+//
+// Threading support:
+// Turn this on unconditionally here, it will get turned off again later
+// if no threading API is detected.
+//
+
+#if __PGIC__ >= 11
+
+// options requested by configure --enable-test
+#define BOOST_HAS_PTHREADS
+#define BOOST_HAS_THREADS
+#define BOOST_HAS_PTHREAD_YIELD
+#define BOOST_HAS_NRVO
+#define BOOST_HAS_LONG_LONG
+
+// options --enable-test wants undefined
+#undef BOOST_NO_STDC_NAMESPACE
+#undef BOOST_NO_EXCEPTION_STD_NAMESPACE
+#undef BOOST_DEDUCED_TYPENAME
+
+#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+
+#elif __PGIC__ >= 10
+
+// options requested by configure --enable-test
+#define BOOST_HAS_THREADS
+#define BOOST_HAS_NRVO
+#define BOOST_HAS_LONG_LONG
+#if defined(linux) || defined(__linux) || defined(__linux__)
+#  define BOOST_HAS_STDINT_H
+#endif
+
+// options --enable-test wants undefined
+#undef BOOST_NO_STDC_NAMESPACE
+#undef BOOST_NO_EXCEPTION_STD_NAMESPACE
+#undef BOOST_DEDUCED_TYPENAME
+
+#elif __PGIC__ >= 7
+
+#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_SWPRINTF
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+
+#else
+
+#  error "Pgi compiler not configured - please reconfigure"
+
+#endif
+//
+// C++0x features
+//
+//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_NUMERIC_LIMITS
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_SWPRINTF
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+
+#define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#define BOOST_NO_CXX11_HDR_TYPEINDEX
+#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#define BOOST_NO_CXX11_HDR_TUPLE
+#define BOOST_NO_CXX11_HDR_THREAD
+#define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#define BOOST_NO_CXX11_HDR_REGEX
+#define BOOST_NO_CXX11_HDR_RATIO
+#define BOOST_NO_CXX11_HDR_RANDOM
+#define BOOST_NO_CXX11_HDR_MUTEX
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_HDR_FUTURE
+#define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#define BOOST_NO_CXX11_HDR_CODECVT
+#define BOOST_NO_CXX11_HDR_CHRONO
+#define BOOST_NO_CXX11_HDR_ARRAY
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+//
+// version check:
+// probably nothing to do here?
+
diff --git a/libktorrent/miniboost/boost/config/compiler/sgi_mipspro.hpp b/libktorrent/miniboost/boost/config/compiler/sgi_mipspro.hpp
new file mode 100644
index 00000000..90688314
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/sgi_mipspro.hpp
@@ -0,0 +1,29 @@
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  SGI C++ compiler setup:
+
+#define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION)
+
+#include "boost/config/compiler/common_edg.hpp"
+
+//
+// Threading support:
+// Turn this on unconditionally here, it will get turned off again later
+// if no threading API is detected.
+//
+#define BOOST_HAS_THREADS
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+
+#undef BOOST_NO_SWPRINTF
+#undef BOOST_DEDUCED_TYPENAME
+
+//
+// version check:
+// probably nothing to do here?
+
+
diff --git a/libktorrent/miniboost/boost/config/compiler/sunpro_cc.hpp b/libktorrent/miniboost/boost/config/compiler/sunpro_cc.hpp
new file mode 100644
index 00000000..f2c85762
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/sunpro_cc.hpp
@@ -0,0 +1,154 @@
+//  (C) Copyright John Maddock 2001.
+//  (C) Copyright Jens Maurer 2001 - 2003.
+//  (C) Copyright Peter Dimov 2002.
+//  (C) Copyright Aleksey Gurtovoy 2002 - 2003.
+//  (C) Copyright David Abrahams 2002.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Sun C++ compiler setup:
+
+#    if __SUNPRO_CC <= 0x500
+#      define BOOST_NO_MEMBER_TEMPLATES
+#      define BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#    endif
+
+#    if (__SUNPRO_CC <= 0x520)
+       //
+       // Sunpro 5.2 and earler:
+       //
+       // although sunpro 5.2 supports the syntax for
+       // inline initialization it often gets the value
+       // wrong, especially where the value is computed
+       // from other constants (J Maddock 6th May 2001)
+#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+
+       // Although sunpro 5.2 supports the syntax for
+       // partial specialization, it often seems to
+       // bind to the wrong specialization.  Better
+       // to disable it until suppport becomes more stable
+       // (J Maddock 6th May 2001).
+#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#    endif
+
+#    if (__SUNPRO_CC <= 0x530)
+       // Requesting debug info (-g) with Boost.Python results
+       // in an internal compiler error for "static const"
+       // initialized in-class.
+       //    >> Assertion:   (../links/dbg_cstabs.cc, line 611)
+       //         while processing ../test.cpp at line 0.
+       // (Jens Maurer according to Gottfried Ganssauge 04 Mar 2002)
+#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+
+       // SunPro 5.3 has better support for partial specialization,
+       // but breaks when compiling std::less >
+       // (Jens Maurer 4 Nov 2001).
+
+       // std::less specialization fixed as reported by George
+       // Heintzelman; partial specialization re-enabled
+       // (Peter Dimov 17 Jan 2002)
+
+//#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+       // integral constant expressions with 64 bit numbers fail
+#      define BOOST_NO_INTEGRAL_INT64_T
+#    endif
+
+#    if (__SUNPRO_CC < 0x570)
+#      define BOOST_NO_TEMPLATE_TEMPLATES
+       // see http://lists.boost.org/MailArchives/boost/msg47184.php
+       // and http://lists.boost.org/MailArchives/boost/msg47220.php
+#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+#      define BOOST_NO_SFINAE
+#      define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
+#    endif
+#    if (__SUNPRO_CC <= 0x580)
+#      define BOOST_NO_IS_ABSTRACT
+#    endif
+
+#    if (__SUNPRO_CC <= 0x5100)
+       // Sun 5.10 may not correctly value-initialize objects of
+       // some user defined types, as was reported in April 2010
+       // (CR 6947016), and confirmed by Steve Clamage.
+       // (Niels Dekker, LKEB, May 2010).
+#      define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+#    endif
+
+//
+// Dynamic shared object (DSO) and dynamic-link library (DLL) support
+//
+#if __SUNPRO_CC > 0x500
+#  define BOOST_SYMBOL_EXPORT __global
+#  define BOOST_SYMBOL_IMPORT __global
+#  define BOOST_SYMBOL_VISIBLE __global
+#endif
+
+
+
+//
+// Issues that effect all known versions:
+//
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_ADL_BARRIER
+
+//
+// C++0x features
+//
+#  define BOOST_HAS_LONG_LONG
+
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_NO_CXX11_SCOPED_ENUMS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+
+//
+// Version
+//
+
+#define BOOST_COMPILER "Sun compiler version " BOOST_STRINGIZE(__SUNPRO_CC)
+
+//
+// versions check:
+// we don't support sunpro prior to version 4:
+#if __SUNPRO_CC < 0x400
+#error "Compiler not supported or configured - please reconfigure"
+#endif
+//
+// last known and checked version is 0x590:
+#if (__SUNPRO_CC > 0x590)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
diff --git a/libktorrent/miniboost/boost/config/compiler/vacpp.hpp b/libktorrent/miniboost/boost/config/compiler/vacpp.hpp
new file mode 100644
index 00000000..bb7d5f50
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/vacpp.hpp
@@ -0,0 +1,132 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright Toon Knapen 2001 - 2003.
+//  (C) Copyright Lie-Quan Lee 2001.
+//  (C) Copyright Markus Schoepflin 2002 - 2003.
+//  (C) Copyright Beman Dawes 2002 - 2003.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Visual Age (IBM) C++ compiler setup:
+
+#if __IBMCPP__ <= 501
+#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#  define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
+#endif
+
+#if (__IBMCPP__ <= 502)
+// Actually the compiler supports inclass member initialization but it
+// requires a definition for the class member and it doesn't recognize
+// it as an integral constant expression when used as a template argument.
+#  define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+#  define BOOST_NO_INTEGRAL_INT64_T
+#  define BOOST_NO_MEMBER_TEMPLATE_KEYWORD
+#endif
+
+#if (__IBMCPP__ <= 600) || !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
+#endif
+
+#if (__IBMCPP__ <= 1110)
+// XL C++ V11.1 and earlier versions may not always value-initialize
+// a temporary object T(), when T is a non-POD aggregate class type.
+// Michael Wong (IBM Canada Ltd) has confirmed this issue and gave it
+// high priority. -- Niels Dekker (LKEB), May 2010.
+#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+#endif
+
+//
+// On AIX thread support seems to be indicated by _THREAD_SAFE:
+//
+#ifdef _THREAD_SAFE
+#  define BOOST_HAS_THREADS
+#endif
+
+#define BOOST_COMPILER "IBM Visual Age version " BOOST_STRINGIZE(__IBMCPP__)
+
+//
+// versions check:
+// we don't support Visual age prior to version 5:
+#if __IBMCPP__ < 500
+#error "Compiler not supported or configured - please reconfigure"
+#endif
+//
+// last known and checked version is 1210:
+#if (__IBMCPP__ > 1210)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+// Some versions of the compiler have issues with default arguments on partial specializations
+#if __IBMCPP__ <= 1010
+#define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+#endif
+
+//
+// C++0x features
+//
+//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
+//
+#if ! __IBMCPP_AUTO_TYPEDEDUCTION
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#endif
+#if ! __IBMCPP_UTF_LITERAL__
+#  define BOOST_NO_CXX11_CHAR16_T
+#  define BOOST_NO_CXX11_CHAR32_T
+#endif
+#if ! __IBMCPP_CONSTEXPR
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
+#if ! __IBMCPP_DECLTYPE
+#  define BOOST_NO_CXX11_DECLTYPE
+#else
+#  define BOOST_HAS_DECLTYPE
+#endif
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#if ! __IBMCPP_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#endif
+#if ! __IBMCPP_EXTERN_TEMPLATE
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#endif
+#if ! __IBMCPP_VARIADIC_TEMPLATES
+// not enabled separately at this time
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#if ! __IBMCPP_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+#if ! __IBMCPP_SCOPED_ENUM
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#if ! __IBMCPP_STATIC_ASSERT
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#endif
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#if ! __IBMCPP_VARIADIC_TEMPLATES
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif
+#if ! __C99_MACRO_WITH_VA_ARGS
+#  define BOOST_NO_CXX11_VARIADIC_MACROS
+#endif
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
diff --git a/libktorrent/miniboost/boost/config/compiler/visualc.hpp b/libktorrent/miniboost/boost/config/compiler/visualc.hpp
new file mode 100644
index 00000000..842f0865
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/compiler/visualc.hpp
@@ -0,0 +1,262 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright Darin Adler 2001 - 2002.
+//  (C) Copyright Peter Dimov 2001.
+//  (C) Copyright Aleksey Gurtovoy 2002.
+//  (C) Copyright David Abrahams 2002 - 2003.
+//  (C) Copyright Beman Dawes 2002 - 2003.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+//
+//  Microsoft Visual C++ compiler setup:
+//
+//  We need to be careful with the checks in this file, as contrary
+//  to popular belief there are versions with _MSC_VER with the final
+//  digit non-zero (mainly the MIPS cross compiler).
+//
+//  So we either test _MSC_VER >= XXXX or else _MSC_VER < XXXX.
+//  No other comparisons (==, >, or <=) are safe.
+//
+
+#define BOOST_MSVC _MSC_VER
+
+//
+// Helper macro BOOST_MSVC_FULL_VER for use in Boost code:
+//
+#if _MSC_FULL_VER > 100000000
+#  define BOOST_MSVC_FULL_VER _MSC_FULL_VER
+#else
+#  define BOOST_MSVC_FULL_VER (_MSC_FULL_VER * 10)
+#endif
+
+// Attempt to suppress VC6 warnings about the length of decorated names (obsolete):
+#pragma warning( disable : 4503 ) // warning: decorated name length exceeded
+
+#define BOOST_HAS_PRAGMA_ONCE
+
+//
+// versions check:
+// we don't support Visual C++ prior to version 7.1:
+#if _MSC_VER < 1310
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+
+#if _MSC_FULL_VER < 180020827
+#  define BOOST_NO_FENV_H
+#endif
+
+#if _MSC_VER < 1400
+// although a conforming signature for swprint exists in VC7.1
+// it appears not to actually work:
+#  define BOOST_NO_SWPRINTF
+// Our extern template tests also fail for this compiler:
+#  define BOOST_NO_CXX11_EXTERN_TEMPLATE
+// Variadic macros do not exist for VC7.1 and lower
+#  define BOOST_NO_CXX11_VARIADIC_MACROS
+#endif
+
+#if _MSC_VER < 1500  // 140X == VC++ 8.0
+#  define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#endif
+
+#if _MSC_VER < 1600  // 150X == VC++ 9.0
+   // A bug in VC9:
+#  define BOOST_NO_ADL_BARRIER
+#endif
+
+
+// MSVC (including the latest checked version) has not yet completely
+// implemented value-initialization, as is reported:
+// "VC++ does not value-initialize members of derived classes without
+// user-declared constructor", reported in 2009 by Sylvester Hesp:
+// https://connect.microsoft.com/VisualStudio/feedback/details/484295
+// "Presence of copy constructor breaks member class initialization",
+// reported in 2009 by Alex Vakulenko:
+// https://connect.microsoft.com/VisualStudio/feedback/details/499606
+// "Value-initialization in new-expression", reported in 2005 by
+// Pavel Kuznetsov (MetaCommunications Engineering):
+// https://connect.microsoft.com/VisualStudio/feedback/details/100744
+// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
+// (Niels Dekker, LKEB, May 2010)
+#  define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#  define BOOST_NO_INTRINSIC_WCHAR_T
+#endif
+
+//
+// check for exception handling support:
+#if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+
+//
+// __int64 support:
+//
+#define BOOST_HAS_MS_INT64
+#if defined(_MSC_EXTENSIONS) || (_MSC_VER >= 1400)
+#   define BOOST_HAS_LONG_LONG
+#else
+#   define BOOST_NO_LONG_LONG
+#endif
+#if (_MSC_VER >= 1400) && !defined(_DEBUG)
+#   define BOOST_HAS_NRVO
+#endif
+//
+// disable Win32 API's if compiler extensions are
+// turned off:
+//
+#if !defined(_MSC_EXTENSIONS) && !defined(BOOST_DISABLE_WIN32)
+#  define BOOST_DISABLE_WIN32
+#endif
+#if !defined(_CPPRTTI) && !defined(BOOST_NO_RTTI)
+#  define BOOST_NO_RTTI
+#endif
+
+//
+// TR1 features:
+//
+#if _MSC_VER >= 1700
+// # define BOOST_HAS_TR1_HASH			// don't know if this is true yet.
+// # define BOOST_HAS_TR1_TYPE_TRAITS	// don't know if this is true yet.
+# define BOOST_HAS_TR1_UNORDERED_MAP
+# define BOOST_HAS_TR1_UNORDERED_SET
+#endif
+
+//
+// C++0x features
+//
+//   See above for BOOST_NO_LONG_LONG
+
+// C++ features supported by VC++ 10 (aka 2010)
+//
+#if _MSC_VER < 1600
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  define BOOST_NO_CXX11_LAMBDAS
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#  define BOOST_NO_CXX11_NULLPTR
+#  define BOOST_NO_CXX11_DECLTYPE
+#endif // _MSC_VER < 1600
+
+#if _MSC_VER >= 1600
+#  define BOOST_HAS_STDINT_H
+#endif
+
+// C++11 features supported by VC++ 11 (aka 2012)
+//
+#if _MSC_VER < 1700
+#  define BOOST_NO_CXX11_RANGE_BASED_FOR
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif // _MSC_VER < 1700
+
+// C++11 features supported by VC++ 12 (aka 2013).
+//
+#if _MSC_FULL_VER < 180020827
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#  define BOOST_NO_CXX11_RAW_LITERALS
+#  define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#  define BOOST_NO_CXX11_DECLTYPE_N3276
+#endif
+
+// C++11 features not supported by any versions
+#define BOOST_NO_CXX11_CHAR16_T
+#define BOOST_NO_CXX11_CHAR32_T
+#define BOOST_NO_CXX11_CONSTEXPR
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_INLINE_NAMESPACES
+
+//
+// prefix and suffix headers:
+//
+#ifndef BOOST_ABI_PREFIX
+#  define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp"
+#endif
+#ifndef BOOST_ABI_SUFFIX
+#  define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp"
+#endif
+
+#ifndef BOOST_COMPILER
+// TODO:
+// these things are mostly bogus. 1200 means version 12.0 of the compiler. The
+// artificial versions assigned to them only refer to the versions of some IDE
+// these compilers have been shipped with, and even that is not all of it. Some
+// were shipped with freely downloadable SDKs, others as crosscompilers in eVC.
+// IOW, you can't use these 'versions' in any sensible way. Sorry.
+# if defined(UNDER_CE)
+#   if _MSC_VER < 1400
+      // Note: I'm not aware of any CE compiler with version 13xx
+#      if defined(BOOST_ASSERT_CONFIG)
+#         error "Unknown EVC++ compiler version - please run the configure tests and report the results"
+#      else
+#         pragma message("Unknown EVC++ compiler version - please run the configure tests and report the results")
+#      endif
+#   elif _MSC_VER < 1500
+#     define BOOST_COMPILER_VERSION evc8
+#   elif _MSC_VER < 1600
+#     define BOOST_COMPILER_VERSION evc9
+#   elif _MSC_VER < 1700
+#     define BOOST_COMPILER_VERSION evc10
+#   elif _MSC_VER < 1800 
+#     define BOOST_COMPILER_VERSION evc11 
+#   elif _MSC_VER < 1900 
+#     define BOOST_COMPILER_VERSION evc12
+#   else
+#      if defined(BOOST_ASSERT_CONFIG)
+#         error "Unknown EVC++ compiler version - please run the configure tests and report the results"
+#      else
+#         pragma message("Unknown EVC++ compiler version - please run the configure tests and report the results")
+#      endif
+#   endif
+# else
+#   if _MSC_VER < 1310
+      // Note: Versions up to 7.0 aren't supported.
+#     define BOOST_COMPILER_VERSION 5.0
+#   elif _MSC_VER < 1300
+#     define BOOST_COMPILER_VERSION 6.0
+#   elif _MSC_VER < 1310
+#     define BOOST_COMPILER_VERSION 7.0
+#   elif _MSC_VER < 1400
+#     define BOOST_COMPILER_VERSION 7.1
+#   elif _MSC_VER < 1500
+#     define BOOST_COMPILER_VERSION 8.0
+#   elif _MSC_VER < 1600
+#     define BOOST_COMPILER_VERSION 9.0
+#   elif _MSC_VER < 1700
+#     define BOOST_COMPILER_VERSION 10.0
+#   elif _MSC_VER < 1800 
+#     define BOOST_COMPILER_VERSION 11.0
+#   elif _MSC_VER < 1900
+#     define BOOST_COMPILER_VERSION 12.0
+#   else
+#     define BOOST_COMPILER_VERSION _MSC_VER
+#   endif
+# endif
+
+#  define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
+#endif
+
+//
+// last known and checked version is 18.00.20827.3 (VC12 RC, aka 2013 RC):
+#if (_MSC_VER > 1800 && _MSC_FULL_VER > 180020827)
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  else
+#     pragma message("Unknown compiler version - please run the configure tests and report the results")
+#  endif
+#endif
diff --git a/libktorrent/miniboost/boost/config/no_tr1/cmath.hpp b/libktorrent/miniboost/boost/config/no_tr1/cmath.hpp
new file mode 100644
index 00000000..d8268d84
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/no_tr1/cmath.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2008.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The aim of this header is just to include  but to do
+// so in a way that does not result in recursive inclusion of
+// the Boost TR1 components if boost/tr1/tr1/cmath is in the
+// include search path.  We have to do this to avoid circular
+// dependencies:
+//
+
+#ifndef BOOST_CONFIG_CMATH
+#  define BOOST_CONFIG_CMATH
+
+#  ifndef BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_RECURSION
+#     define BOOST_CONFIG_NO_CMATH_RECURSION
+#  endif
+
+#  include 
+
+#  ifdef BOOST_CONFIG_NO_CMATH_RECURSION
+#     undef BOOST_TR1_NO_RECURSION
+#     undef BOOST_CONFIG_NO_CMATH_RECURSION
+#  endif
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/no_tr1/complex.hpp b/libktorrent/miniboost/boost/config/no_tr1/complex.hpp
new file mode 100644
index 00000000..ca200922
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/no_tr1/complex.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The aim of this header is just to include  but to do
+// so in a way that does not result in recursive inclusion of
+// the Boost TR1 components if boost/tr1/tr1/complex is in the
+// include search path.  We have to do this to avoid circular
+// dependencies:
+//
+
+#ifndef BOOST_CONFIG_COMPLEX
+#  define BOOST_CONFIG_COMPLEX
+
+#  ifndef BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_RECURSION
+#     define BOOST_CONFIG_NO_COMPLEX_RECURSION
+#  endif
+
+#  include 
+
+#  ifdef BOOST_CONFIG_NO_COMPLEX_RECURSION
+#     undef BOOST_TR1_NO_RECURSION
+#     undef BOOST_CONFIG_NO_COMPLEX_RECURSION
+#  endif
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/no_tr1/functional.hpp b/libktorrent/miniboost/boost/config/no_tr1/functional.hpp
new file mode 100644
index 00000000..e395efc1
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/no_tr1/functional.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The aim of this header is just to include  but to do
+// so in a way that does not result in recursive inclusion of
+// the Boost TR1 components if boost/tr1/tr1/functional is in the
+// include search path.  We have to do this to avoid circular
+// dependencies:
+//
+
+#ifndef BOOST_CONFIG_FUNCTIONAL
+#  define BOOST_CONFIG_FUNCTIONAL
+
+#  ifndef BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_RECURSION
+#     define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
+#  endif
+
+#  include 
+
+#  ifdef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
+#     undef BOOST_TR1_NO_RECURSION
+#     undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
+#  endif
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/no_tr1/memory.hpp b/libktorrent/miniboost/boost/config/no_tr1/memory.hpp
new file mode 100644
index 00000000..2b5d2080
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/no_tr1/memory.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The aim of this header is just to include  but to do
+// so in a way that does not result in recursive inclusion of
+// the Boost TR1 components if boost/tr1/tr1/memory is in the
+// include search path.  We have to do this to avoid circular
+// dependencies:
+//
+
+#ifndef BOOST_CONFIG_MEMORY
+#  define BOOST_CONFIG_MEMORY
+
+#  ifndef BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_RECURSION
+#     define BOOST_CONFIG_NO_MEMORY_RECURSION
+#  endif
+
+#  include 
+
+#  ifdef BOOST_CONFIG_NO_MEMORY_RECURSION
+#     undef BOOST_TR1_NO_RECURSION
+#     undef BOOST_CONFIG_NO_MEMORY_RECURSION
+#  endif
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/no_tr1/utility.hpp b/libktorrent/miniboost/boost/config/no_tr1/utility.hpp
new file mode 100644
index 00000000..dea8f115
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/no_tr1/utility.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The aim of this header is just to include  but to do
+// so in a way that does not result in recursive inclusion of
+// the Boost TR1 components if boost/tr1/tr1/utility is in the
+// include search path.  We have to do this to avoid circular
+// dependencies:
+//
+
+#ifndef BOOST_CONFIG_UTILITY
+#  define BOOST_CONFIG_UTILITY
+
+#  ifndef BOOST_TR1_NO_RECURSION
+#     define BOOST_TR1_NO_RECURSION
+#     define BOOST_CONFIG_NO_UTILITY_RECURSION
+#  endif
+
+#  include 
+
+#  ifdef BOOST_CONFIG_NO_UTILITY_RECURSION
+#     undef BOOST_TR1_NO_RECURSION
+#     undef BOOST_CONFIG_NO_UTILITY_RECURSION
+#  endif
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/platform/aix.hpp b/libktorrent/miniboost/boost/config/platform/aix.hpp
new file mode 100644
index 00000000..894ef42c
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/aix.hpp
@@ -0,0 +1,33 @@
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  IBM/Aix specific config options:
+
+#define BOOST_PLATFORM "IBM Aix"
+
+#define BOOST_HAS_UNISTD_H
+#define BOOST_HAS_NL_TYPES_H
+#define BOOST_HAS_NANOSLEEP
+#define BOOST_HAS_CLOCK_GETTIME
+
+// This needs support in "boost/cstdint.hpp" exactly like FreeBSD.
+// This platform has header named  which includes all
+// the things needed.
+#define BOOST_HAS_STDINT_H
+
+// Threading API's:
+#define BOOST_HAS_PTHREADS
+#define BOOST_HAS_PTHREAD_DELAY_NP
+#define BOOST_HAS_SCHED_YIELD
+//#define BOOST_HAS_PTHREAD_YIELD
+
+// boilerplate code:
+#include 
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/amigaos.hpp b/libktorrent/miniboost/boost/config/platform/amigaos.hpp
new file mode 100644
index 00000000..34bcf412
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/amigaos.hpp
@@ -0,0 +1,15 @@
+//  (C) Copyright John Maddock 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+#define BOOST_PLATFORM "AmigaOS"
+
+#define BOOST_DISABLE_THREADS
+#define BOOST_NO_CWCHAR
+#define BOOST_NO_STD_WSTRING
+#define BOOST_NO_INTRINSIC_WCHAR_T
+ 
+
diff --git a/libktorrent/miniboost/boost/config/platform/beos.hpp b/libktorrent/miniboost/boost/config/platform/beos.hpp
new file mode 100644
index 00000000..48c3d8dc
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/beos.hpp
@@ -0,0 +1,26 @@
+//  (C) Copyright John Maddock 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  BeOS specific config options:
+
+#define BOOST_PLATFORM "BeOS"
+
+#define BOOST_NO_CWCHAR
+#define BOOST_NO_CWCTYPE
+#define BOOST_HAS_UNISTD_H
+
+#define BOOST_HAS_BETHREADS
+
+#ifndef BOOST_DISABLE_THREADS
+#  define BOOST_HAS_THREADS
+#endif
+
+// boilerplate code:
+#include 
+ 
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/bsd.hpp b/libktorrent/miniboost/boost/config/platform/bsd.hpp
new file mode 100644
index 00000000..a0142978
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/bsd.hpp
@@ -0,0 +1,86 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Darin Adler 2001. 
+//  (C) Copyright Douglas Gregor 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  generic BSD config options:
+
+#if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
+#error "This platform is not BSD"
+#endif
+
+#ifdef __FreeBSD__
+#define BOOST_PLATFORM "FreeBSD " BOOST_STRINGIZE(__FreeBSD__)
+#elif defined(__NetBSD__)
+#define BOOST_PLATFORM "NetBSD " BOOST_STRINGIZE(__NetBSD__)
+#elif defined(__OpenBSD__)
+#define BOOST_PLATFORM "OpenBSD " BOOST_STRINGIZE(__OpenBSD__)
+#elif defined(__DragonFly__)
+#define BOOST_PLATFORM "DragonFly " BOOST_STRINGIZE(__DragonFly__)
+#endif
+
+//
+// is this the correct version check?
+// FreeBSD has  but does not
+// advertise the fact in :
+//
+#if (defined(__FreeBSD__) && (__FreeBSD__ >= 3)) || defined(__DragonFly__)
+#  define BOOST_HAS_NL_TYPES_H
+#endif
+
+//
+// FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in 
+// and not in 
+//
+#if (defined(__FreeBSD__) && (__FreeBSD__ <= 3))\
+   || defined(__OpenBSD__) || defined(__DragonFly__) 
+#  define BOOST_HAS_PTHREADS
+#endif
+
+//
+// No wide character support in the BSD header files:
+//
+#if defined(__NetBSD__)
+#define __NetBSD_GCC__ (__GNUC__         * 1000000 \
+                       + __GNUC_MINOR__ *    1000 \
+                       + __GNUC_PATCHLEVEL__)
+// XXX - the following is required until c++config.h
+//       defines _GLIBCXX_HAVE_SWPRINTF and friends
+//       or the preprocessor conditionals are removed
+//       from the cwchar header.
+#define _GLIBCXX_HAVE_SWPRINTF 1
+#endif
+
+#if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
+      || (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) || defined(__DragonFly__))
+#  define BOOST_NO_CWCHAR
+#endif
+//
+// The BSD  has macros only, no functions:
+//
+#if !defined(__OpenBSD__) || defined(__DragonFly__)
+#  define BOOST_NO_CTYPE_FUNCTIONS
+#endif
+
+//
+// thread API's not auto detected:
+//
+#define BOOST_HAS_SCHED_YIELD
+#define BOOST_HAS_NANOSLEEP
+#define BOOST_HAS_GETTIMEOFDAY
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#define BOOST_HAS_SIGACTION
+
+// boilerplate code:
+#define BOOST_HAS_UNISTD_H
+#include 
+
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/cray.hpp b/libktorrent/miniboost/boost/config/platform/cray.hpp
new file mode 100644
index 00000000..5c476e41
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/cray.hpp
@@ -0,0 +1,18 @@
+//  (C) Copyright John Maddock 2011.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org for most recent version.
+
+//  SGI Irix specific config options:
+
+#define BOOST_PLATFORM "Cray"
+
+// boilerplate code:
+#define BOOST_HAS_UNISTD_H
+#include 
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/cygwin.hpp b/libktorrent/miniboost/boost/config/platform/cygwin.hpp
new file mode 100644
index 00000000..b7ef572f
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/cygwin.hpp
@@ -0,0 +1,58 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  cygwin specific config options:
+
+#define BOOST_PLATFORM "Cygwin"
+#define BOOST_HAS_DIRENT_H
+#define BOOST_HAS_LOG1P
+#define BOOST_HAS_EXPM1
+
+//
+// Threading API:
+// See if we have POSIX threads, if we do use them, otherwise
+// revert to native Win threads.
+#define BOOST_HAS_UNISTD_H
+#include 
+#if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS)
+#  define BOOST_HAS_PTHREADS
+#  define BOOST_HAS_SCHED_YIELD
+#  define BOOST_HAS_GETTIMEOFDAY
+#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  define BOOST_HAS_SIGACTION
+#else
+#  if !defined(BOOST_HAS_WINTHREADS)
+#     define BOOST_HAS_WINTHREADS
+#  endif
+#  define BOOST_HAS_FTIME
+#endif
+
+//
+// find out if we have a stdint.h, there should be a better way to do this:
+//
+#include 
+#ifdef _STDINT_H
+#define BOOST_HAS_STDINT_H
+#endif
+
+/// Cygwin has no fenv.h
+#define BOOST_NO_FENV_H
+
+// boilerplate code:
+#include 
+
+//
+// Cygwin lies about XSI conformance, there is no nl_types.h:
+//
+#ifdef BOOST_HAS_NL_TYPES_H
+#  undef BOOST_HAS_NL_TYPES_H
+#endif
+ 
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/hpux.hpp b/libktorrent/miniboost/boost/config/platform/hpux.hpp
new file mode 100644
index 00000000..19ce68e5
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/hpux.hpp
@@ -0,0 +1,87 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2001 - 2003. 
+//  (C) Copyright David Abrahams 2002. 
+//  (C) Copyright Toon Knapen 2003. 
+//  (C) Copyright Boris Gubenko 2006 - 2007.
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  hpux specific config options:
+
+#define BOOST_PLATFORM "HP-UX"
+
+// In principle, HP-UX has a nice  under the name 
+// However, it has the following problem:
+// Use of UINT32_C(0) results in "0u l" for the preprocessed source
+// (verifyable with gcc 2.95.3)
+#if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__HP_aCC)
+#  define BOOST_HAS_STDINT_H
+#endif
+
+#if !(defined(__HP_aCC) || !defined(_INCLUDE__STDC_A1_SOURCE))
+#  define BOOST_NO_SWPRINTF
+#endif
+#if defined(__HP_aCC) && !defined(_INCLUDE__STDC_A1_SOURCE)
+#  define BOOST_NO_CWCTYPE
+#endif
+
+#if defined(__GNUC__)
+#  if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))
+      // GNU C on HP-UX does not support threads (checked up to gcc 3.3)
+#     define BOOST_DISABLE_THREADS
+#  elif !defined(BOOST_DISABLE_THREADS)
+      // threads supported from gcc-3.3 onwards:
+#     define BOOST_HAS_THREADS
+#     define BOOST_HAS_PTHREADS
+#  endif
+#elif defined(__HP_aCC) && !defined(BOOST_DISABLE_THREADS)
+#  define BOOST_HAS_PTHREADS
+#endif
+
+// boilerplate code:
+#define BOOST_HAS_UNISTD_H
+#include 
+
+// the following are always available:
+#ifndef BOOST_HAS_GETTIMEOFDAY
+#  define BOOST_HAS_GETTIMEOFDAY
+#endif
+#ifndef BOOST_HAS_SCHED_YIELD
+#    define BOOST_HAS_SCHED_YIELD
+#endif
+#ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#endif
+#ifndef BOOST_HAS_NL_TYPES_H
+#    define BOOST_HAS_NL_TYPES_H
+#endif
+#ifndef BOOST_HAS_NANOSLEEP
+#    define BOOST_HAS_NANOSLEEP
+#endif
+#ifndef BOOST_HAS_GETTIMEOFDAY
+#    define BOOST_HAS_GETTIMEOFDAY
+#endif
+#ifndef BOOST_HAS_DIRENT_H
+#    define BOOST_HAS_DIRENT_H
+#endif
+#ifndef BOOST_HAS_CLOCK_GETTIME
+#    define BOOST_HAS_CLOCK_GETTIME
+#endif
+#ifndef BOOST_HAS_SIGACTION
+#  define BOOST_HAS_SIGACTION
+#endif
+#ifndef BOOST_HAS_NRVO 
+#  ifndef __parisc
+#    define BOOST_HAS_NRVO
+#  endif
+#endif
+#ifndef BOOST_HAS_LOG1P 
+#  define BOOST_HAS_LOG1P
+#endif
+#ifndef BOOST_HAS_EXPM1
+#  define BOOST_HAS_EXPM1
+#endif
+
diff --git a/libktorrent/miniboost/boost/config/platform/irix.hpp b/libktorrent/miniboost/boost/config/platform/irix.hpp
new file mode 100644
index 00000000..aeae49c8
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/irix.hpp
@@ -0,0 +1,31 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org for most recent version.
+
+//  SGI Irix specific config options:
+
+#define BOOST_PLATFORM "SGI Irix"
+
+#define BOOST_NO_SWPRINTF 
+//
+// these are not auto detected by POSIX feature tests:
+//
+#define BOOST_HAS_GETTIMEOFDAY
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+
+#ifdef __GNUC__
+   // GNU C on IRIX does not support threads (checked up to gcc 3.3)
+#  define BOOST_DISABLE_THREADS
+#endif
+
+// boilerplate code:
+#define BOOST_HAS_UNISTD_H
+#include 
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/linux.hpp b/libktorrent/miniboost/boost/config/platform/linux.hpp
new file mode 100644
index 00000000..a02aff78
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/linux.hpp
@@ -0,0 +1,103 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  linux specific config options:
+
+#define BOOST_PLATFORM "linux"
+
+// make sure we have __GLIBC_PREREQ if available at all
+#ifdef __cplusplus
+#include 
+#else
+#include 
+#endif
+
+//
+//  added to glibc 2.1.1
+// We can only test for 2.1 though:
+//
+#if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1)))
+   //  defines int64_t unconditionally, but  defines
+   // int64_t only if __GNUC__.  Thus, assume a fully usable 
+   // only when using GCC.
+#  if defined __GNUC__
+#    define BOOST_HAS_STDINT_H
+#  endif
+#endif
+
+#if defined(__LIBCOMO__)
+   //
+   // como on linux doesn't have std:: c functions:
+   // NOTE: versions of libcomo prior to beta28 have octal version numbering,
+   // e.g. version 25 is 21 (dec)
+   //
+#  if __LIBCOMO_VERSION__ <= 20
+#    define BOOST_NO_STDC_NAMESPACE
+#  endif
+
+#  if __LIBCOMO_VERSION__ <= 21
+#    define BOOST_NO_SWPRINTF
+#  endif
+
+#endif
+
+//
+// If glibc is past version 2 then we definitely have
+// gettimeofday, earlier versions may or may not have it:
+//
+#if defined(__GLIBC__) && (__GLIBC__ >= 2)
+#  define BOOST_HAS_GETTIMEOFDAY
+#endif
+
+#ifdef __USE_POSIX199309
+#  define BOOST_HAS_NANOSLEEP
+#endif
+
+#if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
+// __GLIBC_PREREQ is available since 2.1.2
+
+   // swprintf is available since glibc 2.2.0
+#  if !__GLIBC_PREREQ(2,2) || (!defined(__USE_ISOC99) && !defined(__USE_UNIX98))
+#    define BOOST_NO_SWPRINTF
+#  endif
+#else
+#  define BOOST_NO_SWPRINTF
+#endif
+
+// boilerplate code:
+#define BOOST_HAS_UNISTD_H
+#include 
+#define BOOST_HAS_PTHREAD_YIELD
+
+#ifndef __GNUC__
+//
+// if the compiler is not gcc we still need to be able to parse
+// the GNU system headers, some of which (mainly )
+// use GNU specific extensions:
+//
+#  ifndef __extension__
+#     define __extension__
+#  endif
+#  ifndef __const__
+#     define __const__ const
+#  endif
+#  ifndef __volatile__
+#     define __volatile__ volatile
+#  endif
+#  ifndef __signed__
+#     define __signed__ signed
+#  endif
+#  ifndef __typeof__
+#     define __typeof__ typeof
+#  endif
+#  ifndef __inline__
+#     define __inline__ inline
+#  endif
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/macos.hpp b/libktorrent/miniboost/boost/config/platform/macos.hpp
new file mode 100644
index 00000000..6d876b12
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/macos.hpp
@@ -0,0 +1,87 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Darin Adler 2001 - 2002. 
+//  (C) Copyright Bill Kempf 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Mac OS specific config options:
+
+#define BOOST_PLATFORM "Mac OS"
+
+#if __MACH__ && !defined(_MSL_USING_MSL_C)
+
+// Using the Mac OS X system BSD-style C library.
+
+#  ifndef BOOST_HAS_UNISTD_H
+#    define BOOST_HAS_UNISTD_H
+#  endif
+//
+// Begin by including our boilerplate code for POSIX
+// feature detection, this is safe even when using
+// the MSL as Metrowerks supply their own 
+// to replace the platform-native BSD one. G++ users
+// should also always be able to do this on MaxOS X.
+//
+#  include 
+#  ifndef BOOST_HAS_STDINT_H
+#     define BOOST_HAS_STDINT_H
+#  endif
+
+//
+// BSD runtime has pthreads, sigaction, sched_yield and gettimeofday,
+// of these only pthreads are advertised in , so set the 
+// other options explicitly:
+//
+#  define BOOST_HAS_SCHED_YIELD
+#  define BOOST_HAS_GETTIMEOFDAY
+#  define BOOST_HAS_SIGACTION
+
+#  if (__GNUC__ < 3) && !defined( __APPLE_CC__)
+
+// GCC strange "ignore std" mode works better if you pretend everything
+// is in the std namespace, for the most part.
+
+#    define BOOST_NO_STDC_NAMESPACE
+#  endif
+
+#  if (__GNUC__ == 4)
+
+// Both gcc and intel require these.  
+#    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#    define BOOST_HAS_NANOSLEEP
+
+#  endif
+
+#else
+
+// Using the MSL C library.
+
+// We will eventually support threads in non-Carbon builds, but we do
+// not support this yet.
+#  if ( defined(TARGET_API_MAC_CARBON) && TARGET_API_MAC_CARBON ) || ( defined(TARGET_CARBON) && TARGET_CARBON )
+
+#  if !defined(BOOST_HAS_PTHREADS)
+// MPTasks support is deprecated/removed from Boost:
+//#    define BOOST_HAS_MPTASKS
+#  elif ( __dest_os == __mac_os_x )
+// We are doing a Carbon/Mach-O/MSL build which has pthreads, but only the
+// gettimeofday and no posix.
+#  define BOOST_HAS_GETTIMEOFDAY
+#  endif
+
+#ifdef BOOST_HAS_PTHREADS
+#  define BOOST_HAS_THREADS
+#endif
+
+// The remote call manager depends on this.
+#    define BOOST_BIND_ENABLE_PASCAL
+
+#  endif
+
+#endif
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/qnxnto.hpp b/libktorrent/miniboost/boost/config/platform/qnxnto.hpp
new file mode 100644
index 00000000..b1377c8d
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/qnxnto.hpp
@@ -0,0 +1,31 @@
+//  (C) Copyright Jim Douglas 2005. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  QNX specific config options:
+
+#define BOOST_PLATFORM "QNX"
+
+#define BOOST_HAS_UNISTD_H
+#include 
+
+// QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h
+// or log1p and expm1:
+#undef  BOOST_HAS_NL_TYPES_H
+#undef  BOOST_HAS_LOG1P
+#undef  BOOST_HAS_EXPM1
+
+#define BOOST_HAS_PTHREADS
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+
+#define BOOST_HAS_GETTIMEOFDAY
+#define BOOST_HAS_CLOCK_GETTIME
+#define BOOST_HAS_NANOSLEEP
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/solaris.hpp b/libktorrent/miniboost/boost/config/platform/solaris.hpp
new file mode 100644
index 00000000..9f925666
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/solaris.hpp
@@ -0,0 +1,28 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  sun specific config options:
+
+#define BOOST_PLATFORM "Sun Solaris"
+
+#define BOOST_HAS_GETTIMEOFDAY
+
+// boilerplate code:
+#define BOOST_HAS_UNISTD_H
+#include 
+
+//
+// pthreads don't actually work with gcc unless _PTHREADS is defined:
+//
+#if defined(__GNUC__) && defined(_POSIX_THREADS) && !defined(_PTHREADS)
+# undef BOOST_HAS_PTHREADS
+#endif
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/symbian.hpp b/libktorrent/miniboost/boost/config/platform/symbian.hpp
new file mode 100644
index 00000000..e02a7782
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/symbian.hpp
@@ -0,0 +1,97 @@
+//  (C) Copyright Yuriy Krasnoschek 2009. 
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  symbian specific config options:
+
+
+#define BOOST_PLATFORM "Symbian"
+#define BOOST_SYMBIAN 1
+
+
+#if defined(__S60_3X__)
+// Open C / C++ plugin was introdused in this SDK, earlier versions don't have CRT / STL
+#  define BOOST_S60_3rd_EDITION_FP2_OR_LATER_SDK
+// make sure we have __GLIBC_PREREQ if available at all
+#ifdef __cplusplus
+#include 
+#else
+#include 
+#endif// boilerplate code:
+#  define BOOST_HAS_UNISTD_H
+#  include 
+// S60 SDK defines _POSIX_VERSION as POSIX.1
+#  ifndef BOOST_HAS_STDINT_H
+#    define BOOST_HAS_STDINT_H
+#  endif
+#  ifndef BOOST_HAS_GETTIMEOFDAY
+#    define BOOST_HAS_GETTIMEOFDAY
+#  endif
+#  ifndef BOOST_HAS_DIRENT_H
+#    define BOOST_HAS_DIRENT_H
+#  endif
+#  ifndef BOOST_HAS_SIGACTION
+#    define BOOST_HAS_SIGACTION
+#  endif
+#  ifndef BOOST_HAS_PTHREADS
+#    define BOOST_HAS_PTHREADS
+#  endif
+#  ifndef BOOST_HAS_NANOSLEEP
+#    define BOOST_HAS_NANOSLEEP
+#  endif
+#  ifndef BOOST_HAS_SCHED_YIELD
+#    define BOOST_HAS_SCHED_YIELD
+#  endif
+#  ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#    define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  endif
+#  ifndef BOOST_HAS_LOG1P
+#    define BOOST_HAS_LOG1P
+#  endif
+#  ifndef BOOST_HAS_EXPM1
+#    define BOOST_HAS_EXPM1
+#  endif
+#  ifndef BOOST_POSIX_API
+#    define BOOST_POSIX_API
+#  endif
+// endianess support
+#  include 
+// Symbian SDK provides _BYTE_ORDER instead of __BYTE_ORDER
+#  ifndef __LITTLE_ENDIAN
+#    ifdef _LITTLE_ENDIAN
+#      define __LITTLE_ENDIAN _LITTLE_ENDIAN
+#    else
+#      define __LITTLE_ENDIAN 1234
+#    endif
+#  endif
+#  ifndef __BIG_ENDIAN
+#    ifdef _BIG_ENDIAN
+#      define __BIG_ENDIAN _BIG_ENDIAN
+#    else
+#      define __BIG_ENDIAN 4321
+#    endif
+#  endif
+#  ifndef __BYTE_ORDER
+#    define __BYTE_ORDER __LITTLE_ENDIAN // Symbian is LE
+#  endif
+// Known limitations
+#  define BOOST_ASIO_DISABLE_SERIAL_PORT
+#  define BOOST_DATE_TIME_NO_LOCALE
+#  define BOOST_NO_STD_WSTRING
+#  define BOOST_EXCEPTION_DISABLE
+#  define BOOST_NO_EXCEPTIONS
+
+#else // TODO: More platform support e.g. UIQ
+#  error "Unsuppoted Symbian SDK"
+#endif
+
+#if defined(__WINSCW__) && !defined(BOOST_DISABLE_WIN32)
+#  define BOOST_DISABLE_WIN32 // winscw defines WIN32 macro
+#endif
+
+
diff --git a/libktorrent/miniboost/boost/config/platform/vms.hpp b/libktorrent/miniboost/boost/config/platform/vms.hpp
new file mode 100644
index 00000000..f70efcfb
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/vms.hpp
@@ -0,0 +1,25 @@
+//  (C) Copyright Artyom Beilis 2010.  
+//  Use, modification and distribution are subject to the  
+//  Boost Software License, Version 1.0. (See accompanying file  
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 
+
+#ifndef BOOST_CONFIG_PLATFORM_VMS_HPP 
+#define BOOST_CONFIG_PLATFORM_VMS_HPP 
+
+#define BOOST_PLATFORM "OpenVMS" 
+
+#undef  BOOST_HAS_STDINT_H 
+#define BOOST_HAS_UNISTD_H 
+#define BOOST_HAS_NL_TYPES_H 
+#define BOOST_HAS_GETTIMEOFDAY 
+#define BOOST_HAS_DIRENT_H 
+#define BOOST_HAS_PTHREADS 
+#define BOOST_HAS_NANOSLEEP 
+#define BOOST_HAS_CLOCK_GETTIME 
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 
+#define BOOST_HAS_LOG1P 
+#define BOOST_HAS_EXPM1 
+#define BOOST_HAS_THREADS 
+#undef  BOOST_HAS_SCHED_YIELD 
+
+#endif 
diff --git a/libktorrent/miniboost/boost/config/platform/vxworks.hpp b/libktorrent/miniboost/boost/config/platform/vxworks.hpp
new file mode 100644
index 00000000..cdda0158
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/vxworks.hpp
@@ -0,0 +1,369 @@
+//  (C) Copyright Dustin Spicuzza 2009.
+//      Adapted to vxWorks 6.9 by Peter Brockamp 2012.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Since WRS does not yet properly support boost under vxWorks
+//  and this file was badly outdated, but I was keen on using it,
+//  I patched boost myself to make things work. This has been tested
+//  and adapted by me for vxWorks 6.9 *only*, as I'm lacking access
+//  to earlier 6.X versions! The only thing I know for sure is that
+//  very old versions of vxWorks (namely everything below 6.x) are
+//  absolutely unable to use boost. This is mainly due to the completely
+//  outdated libraries and ancient compiler (GCC 2.96 or worse). Do
+//  not even think of getting this to work, a miserable failure will
+//  be guaranteed!
+//  Equally, this file has been tested for RTPs (Real Time Processes)
+//  only, not for DKMs (Downloadable Kernel Modules). These two types
+//  of executables differ largely in the available functionality of
+//  the C-library, STL, and so on. A DKM uses a library similar to those
+//  of vxWorks 5.X - with all its limitations and incompatibilities
+//  with respect to ANSI C++ and STL. So probably there might be problems
+//  with the usage of boost from DKMs. WRS or any voluteers are free to
+//  prove the opposite!
+
+// ====================================================================
+//
+// Some important information regarding the usage of POSIX semaphores:
+// -------------------------------------------------------------------
+//
+// VxWorks as a real time operating system handles threads somewhat
+// different from what "normal" OSes do, regarding their scheduling!
+// This could lead to a scenario called "priority inversion" when using
+// semaphores, see http://en.wikipedia.org/wiki/Priority_inversion.
+//
+// Now, VxWorks POSIX-semaphores for DKM's default to the usage of
+// priority inverting semaphores, which is fine. On the other hand,
+// for RTP's it defaults to using non priority inverting semaphores,
+// which could easily pose a serious problem for a real time process,
+// i.e. deadlocks! To overcome this two possibilities do exist:
+//
+// a) Patch every piece of boost that uses semaphores to instanciate
+//    the proper type of semaphores. This is non-intrusive with respect
+//    to the OS and could relatively easy been done by giving all
+//    semaphores attributes deviating from the default (for in-depth
+//    information see the POSIX functions pthread_mutexattr_init()
+//    and pthread_mutexattr_setprotocol()). However this breaks all
+//    too easily, as with every new version some boost library could
+//    all in a sudden start using semaphores, resurrecting the very
+//    same, hard to locate problem over and over again!
+//
+// b) We could change the default properties for POSIX-semaphores
+//    that VxWorks uses for RTP's and this is being suggested here,
+//    as it will more or less seamlessly integrate with boost. I got
+//    the following information from WRS how to do this, compare
+//    Wind River TSR# 1209768:
+//
+// Instructions for changing the default properties of POSIX-
+// semaphores for RTP's in VxWorks 6.9:
+// - Edit the file /vxworks-6.9/target/usr/src/posix/pthreadLib.c
+//   in the root of your Workbench-installation.
+// - Around line 917 there should be the definition of the default
+//   mutex attributes:
+//
+//   LOCAL pthread_mutexattr_t defaultMutexAttr =
+//       {
+//       PTHREAD_INITIALIZED_OBJ, PTHREAD_PRIO_NONE, 0,
+//       PTHREAD_MUTEX_DEFAULT
+//       };
+//
+//   Here, replace PTHREAD_PRIO_NONE by PTHREAD_PRIO_INHERIT.
+// - Around line 1236 there should be a definition for the function
+//   pthread_mutexattr_init(). A couple of lines below you should
+//   find a block of code like this:
+//
+//   pAttr->mutexAttrStatus      = PTHREAD_INITIALIZED_OBJ;
+//   pAttr->mutexAttrProtocol    = PTHREAD_PRIO_NONE;
+//   pAttr->mutexAttrPrioceiling = 0;
+//   pAttr->mutexAttrType        = PTHREAD_MUTEX_DEFAULT;
+//
+//   Here again, replace PTHREAD_PRIO_NONE by PTHREAD_PRIO_INHERIT.
+// - Finally, rebuild your VSB. This will create a new VxWorks kernel
+//   with the changed properties. That's it! Now, using boost should
+//   no longer cause any problems with task deadlocks!
+//
+// And here's another useful piece of information concerning VxWorks'
+// POSIX-functionality in general:
+// VxWorks is not a genuine POSIX-OS in itself, rather it is using a
+// kind of compatibility layer (sort of a wrapper) to emulate the
+// POSIX-functionality by using its own resources and functions.
+// At the time a task (thread) calls it's first POSIX-function during
+// runtime it is being transformed by the OS into a POSIX-thread.
+// This transformation does include a call to malloc() to allocate the
+// memory required for the housekeeping of POSIX-threads. In a high
+// priority RTP this malloc() call may be highly undesirable, as its
+// timing is more or less unpredictable (depending on what your actual
+// heap looks like). You can circumvent this problem by calling the
+// function thread_self() at a well defined point in the code of the
+// task, e.g. shortly after the task spawns up. Thereby you are able
+// to define the time when the task-transformation will take place and
+// you could shift it to an uncritical point where a malloc() call is
+// tolerable. So, if this could pose a problem for your code, remember
+// to call thread_self() from the affected task at an early stage.
+//
+// ====================================================================
+
+// Block out all versions before vxWorks 6.x, as these don't work:
+// Include header with the vxWorks version information and query them
+#include 
+#if !defined(_WRS_VXWORKS_MAJOR) || (_WRS_VXWORKS_MAJOR < 6)
+#  error "The vxWorks version you're using is so badly outdated,\
+          it doesn't work at all with boost, sorry, no chance!"
+#endif
+
+// Handle versions above 5.X but below 6.9
+#if (_WRS_VXWORKS_MAJOR == 6) && (_WRS_VXWORKS_MINOR < 9)
+// TODO: Starting from what version does vxWorks work with boost?
+// We can't reasonably insert a #warning "" as a user hint here,
+// as this will show up with every file including some boost header,
+// badly bugging the user... So for the time being we just leave it.
+#endif
+
+// vxWorks specific config options:
+// --------------------------------
+#define BOOST_PLATFORM "vxWorks"
+
+// Special behaviour for DKMs:
+#ifdef _WRS_KERNEL
+  // DKMs do not have the -header,
+  // but apparently they do have an intrinsic wchar_t meanwhile!
+#  define BOOST_NO_CWCHAR
+
+  // Lots of wide-functions and -headers are unavailable for DKMs as well:
+#  define BOOST_NO_CWCTYPE
+#  define BOOST_NO_SWPRINTF
+#  define BOOST_NO_STD_WSTRING
+#  define BOOST_NO_STD_WSTREAMBUF
+#endif
+
+// Generally available headers:
+#define BOOST_HAS_UNISTD_H
+#define BOOST_HAS_STDINT_H
+#define BOOST_HAS_DIRENT_H
+#define BOOST_HAS_SLIST
+
+// vxWorks does not have installed an iconv-library by default,
+// so unfortunately no Unicode support from scratch is available!
+// Thus, instead it is suggested to switch to ICU, as this seems
+// to be the most complete and portable option...
+#define BOOST_LOCALE_WITH_ICU
+
+// Generally available functionality:
+#define BOOST_HAS_THREADS
+#define BOOST_HAS_NANOSLEEP
+#define BOOST_HAS_GETTIMEOFDAY
+#define BOOST_HAS_CLOCK_GETTIME
+#define BOOST_HAS_MACRO_USE_FACET
+
+// Generally unavailable functionality, delivered by boost's test function:
+//#define BOOST_NO_DEDUCED_TYPENAME // Commented this out, boost's test gives an errorneous result!
+#define BOOST_NO_CXX11_EXTERN_TEMPLATE
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+
+// Generally available threading API's:
+#define BOOST_HAS_PTHREADS
+#define BOOST_HAS_SCHED_YIELD
+#define BOOST_HAS_SIGACTION
+
+// Functionality available for RTPs only:
+#ifdef __RTP__
+#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  define BOOST_HAS_LOG1P
+#  define BOOST_HAS_EXPM1
+#endif
+
+// Functionality available for DKMs only:
+#ifdef _WRS_KERNEL
+  // Luckily, at the moment there seems to be none!
+#endif
+
+// These #defines allow posix_features to work, since vxWorks doesn't
+// #define them itself for DKMs (for RTPs on the contrary it does):
+#ifdef _WRS_KERNEL
+#  ifndef _POSIX_TIMERS
+#    define _POSIX_TIMERS  1
+#  endif
+#  ifndef _POSIX_THREADS
+#    define _POSIX_THREADS 1
+#  endif
+#endif
+
+// vxWorks doesn't work with asio serial ports:
+#define BOOST_ASIO_DISABLE_SERIAL_PORT
+// TODO: The problem here seems to bee that vxWorks uses its own, very specific
+//       ways to handle serial ports, incompatible with POSIX or anything...
+//       Maybe a specific implementation would be possible, but until the
+//       straight need arises... This implementation would presumably consist
+//       of some vxWorks specific ioctl-calls, etc. Any voluteers?
+
+// vxWorks-around:  #defines CLOCKS_PER_SEC as sysClkRateGet() but
+//                 miserably fails to #include the required  to make
+//                 sysClkRateGet() available! So we manually include it here.
+#ifdef __RTP__
+#  include 
+#  include 
+#endif
+
+// vxWorks-around: In  the macros INT32_C(), UINT32_C(), INT64_C() and
+//                 UINT64_C() are defined errorneously, yielding not a signed/
+//                 unsigned long/long long type, but a signed/unsigned int/long
+//                 type. Eventually this leads to compile errors in ratio_fwd.hpp,
+//                 when trying to define several constants which do not fit into a
+//                 long type! We correct them here by redefining.
+#include 
+
+// Some macro-magic to do the job
+#define VX_JOIN(X, Y)     VX_DO_JOIN(X, Y)
+#define VX_DO_JOIN(X, Y)  VX_DO_JOIN2(X, Y)
+#define VX_DO_JOIN2(X, Y) X##Y
+
+// Correctly setup the macros
+#undef  INT32_C
+#undef  UINT32_C
+#undef  INT64_C
+#undef  UINT64_C
+#define INT32_C(x)  VX_JOIN(x, L)
+#define UINT32_C(x) VX_JOIN(x, UL)
+#define INT64_C(x)  VX_JOIN(x, LL)
+#define UINT64_C(x) VX_JOIN(x, ULL)
+
+// #include Libraries required for the following function adaption
+#include 
+#include 
+#include 
+
+// Use C-linkage for the following helper functions
+extern "C" {
+
+// vxWorks-around: The required functions getrlimit() and getrlimit() are missing.
+//                 But we have the similar functions getprlimit() and setprlimit(),
+//                 which may serve the purpose.
+//                 Problem: The vxWorks-documentation regarding these functions
+//                 doesn't deserve its name! It isn't documented what the first two
+//                 parameters idtype and id mean, so we must fall back to an educated
+//                 guess - null, argh... :-/
+
+// TODO: getprlimit() and setprlimit() do exist for RTPs only, for whatever reason.
+//       Thus for DKMs there would have to be another implementation.
+#ifdef __RTP__
+  inline int getrlimit(int resource, struct rlimit *rlp){
+    return getprlimit(0, 0, resource, rlp);
+  }
+
+  inline int setrlimit(int resource, const struct rlimit *rlp){
+    return setprlimit(0, 0, resource, const_cast(rlp));
+  }
+#endif
+
+// vxWorks has ftruncate() only, so we do simulate truncate():
+inline int truncate(const char *p, off_t l){
+  int fd = open(p, O_WRONLY);
+  if (fd == -1){
+    errno = EACCES;
+    return -1;
+  }
+  if (ftruncate(fd, l) == -1){
+    close(fd);
+    errno = EACCES;
+    return -1;
+  }
+  return close(fd);
+}
+
+// Fake symlink handling by dummy functions:
+inline int symlink(const char*, const char*){
+  // vxWorks has no symlinks -> always return an error!
+  errno = EACCES;
+  return -1;
+}
+
+inline ssize_t readlink(const char*, char*, size_t){
+  // vxWorks has no symlinks -> always return an error!
+  errno = EACCES;
+  return -1;
+}
+
+// vxWorks claims to implement gettimeofday in sys/time.h
+// but nevertheless does not provide it! See
+// https://support.windriver.com/olsPortal/faces/maintenance/techtipDetail_noHeader.jspx?docId=16442&contentId=WR_TECHTIP_006256
+// We implement a surrogate version here via clock_gettime:
+inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  tv->tv_sec  = ts.tv_sec;
+  tv->tv_usec = ts.tv_nsec / 1000;
+  return 0;
+}
+
+// vxWorks does provide neither struct tms nor function times()!
+// We implement an empty dummy-function, simply setting the user
+// and system time to the half of thew actual system ticks-value
+// and the child user and system time to 0.
+// Rather ugly but at least it suppresses compiler errors...
+// Unfortunately, this of course *does* have an severe impact on
+// dependant libraries, actually this is chrono only! Here it will
+// not be possible to correctly use user and system times! But
+// as vxWorks is lacking the ability to calculate user and system
+// process times there seems to be no other possible solution.
+struct tms{
+  clock_t tms_utime;  // User CPU time
+  clock_t tms_stime;  // System CPU time
+  clock_t tms_cutime; // User CPU time of terminated child processes
+  clock_t tms_cstime; // System CPU time of terminated child processes
+};
+
+inline clock_t times(struct tms *t){
+  struct timespec ts;
+  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
+  clock_t ticks(static_cast(static_cast(ts.tv_sec)  * CLOCKS_PER_SEC +
+                                     static_cast(ts.tv_nsec) * CLOCKS_PER_SEC / 1000000.0));
+  t->tms_utime  = ticks/2U;
+  t->tms_stime  = ticks/2U;
+  t->tms_cutime = 0; // vxWorks is lacking the concept of a child process!
+  t->tms_cstime = 0; // -> Set the wait times for childs to 0
+  return ticks;
+}
+
+} // extern "C"
+
+// Put the selfmade functions into the std-namespace, just in case
+namespace std {
+# ifdef __RTP__
+    using ::getrlimit;
+    using ::setrlimit;
+# endif
+  using ::truncate;
+  using ::symlink;
+  using ::readlink;
+  using ::times;
+  using ::gettimeofday;
+}
+
+// Some more macro-magic:
+// vxWorks-around: Some functions are not present or broken in vxWorks
+//                 but may be patched to life via helper macros...
+
+// Include signal.h which might contain a typo to be corrected here
+#include 
+
+#define getpagesize()    sysconf(_SC_PAGESIZE)         // getpagesize is deprecated anyway!
+#ifndef S_ISSOCK
+#  define S_ISSOCK(mode) ((mode & S_IFMT) == S_IFSOCK) // Is file a socket?
+#endif
+#define lstat(p, b)      stat(p, b)                    // lstat() == stat(), as vxWorks has no symlinks!
+#ifndef FPE_FLTINV
+#  define FPE_FLTINV     (FPE_FLTSUB+1)                // vxWorks has no FPE_FLTINV, so define one as a dummy
+#endif
+#if !defined(BUS_ADRALN) && defined(BUS_ADRALNR)
+#  define BUS_ADRALN     BUS_ADRALNR                   // Correct a supposed typo in vxWorks' 
+#endif
+//typedef int              locale_t;                     // locale_t is a POSIX-extension, currently unpresent in vxWorks!
+
+// #include boilerplate code:
+#include 
+
+// vxWorks lies about XSI conformance, there is no nl_types.h:
+#undef BOOST_HAS_NL_TYPES_H
diff --git a/libktorrent/miniboost/boost/config/platform/win32.hpp b/libktorrent/miniboost/boost/config/platform/win32.hpp
new file mode 100644
index 00000000..2a91519e
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/platform/win32.hpp
@@ -0,0 +1,80 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Bill Kempf 2001. 
+//  (C) Copyright Aleksey Gurtovoy 2003. 
+//  (C) Copyright Rene Rivera 2005.
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Win32 specific config options:
+
+#define BOOST_PLATFORM "Win32"
+
+//  Get the information about the MinGW runtime, i.e. __MINGW32_*VERSION.
+#if defined(__MINGW32__)
+#  include <_mingw.h>
+#endif
+
+#if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF)
+#  define BOOST_NO_SWPRINTF
+#endif
+
+//  Default defines for BOOST_SYMBOL_EXPORT and BOOST_SYMBOL_IMPORT
+//  If a compiler doesn't support __declspec(dllexport)/__declspec(dllimport),
+//  its boost/config/compiler/ file must define BOOST_SYMBOL_EXPORT and
+//  BOOST_SYMBOL_IMPORT
+#ifndef BOOST_SYMBOL_EXPORT
+#  define BOOST_HAS_DECLSPEC
+#  define BOOST_SYMBOL_EXPORT __declspec(dllexport)
+#  define BOOST_SYMBOL_IMPORT __declspec(dllimport)
+#endif
+
+#if defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 2) || ((__MINGW32_MAJOR_VERSION == 2) && (__MINGW32_MINOR_VERSION >= 0)))
+#  define BOOST_HAS_STDINT_H
+#  ifndef __STDC_LIMIT_MACROS
+#     define __STDC_LIMIT_MACROS
+#  endif
+#  define BOOST_HAS_DIRENT_H
+#  define BOOST_HAS_UNISTD_H
+#endif
+
+#if defined(__MINGW32__) && (__GNUC__ >= 4)
+#  define BOOST_HAS_EXPM1
+#  define BOOST_HAS_LOG1P
+#  define BOOST_HAS_GETTIMEOFDAY
+#endif
+//
+// Win32 will normally be using native Win32 threads,
+// but there is a pthread library avaliable as an option,
+// we used to disable this when BOOST_DISABLE_WIN32 was 
+// defined but no longer - this should allow some
+// files to be compiled in strict mode - while maintaining
+// a consistent setting of BOOST_HAS_THREADS across
+// all translation units (needed for shared_ptr etc).
+//
+
+#ifndef BOOST_HAS_PTHREADS
+#  define BOOST_HAS_WINTHREADS
+#endif
+
+//
+// WinCE configuration:
+//
+#if defined(_WIN32_WCE) || defined(UNDER_CE)
+#  define BOOST_NO_ANSI_APIS
+// Windows CE does not have a conforming signature for swprintf
+#  define BOOST_NO_SWPRINTF
+#else
+#  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
+#  define BOOST_HAS_THREADEX
+#  define BOOST_HAS_GETSYSTEMTIMEASFILETIME
+#endif
+
+#ifndef BOOST_DISABLE_WIN32
+// WEK: Added
+#define BOOST_HAS_FTIME
+#define BOOST_WINDOWS 1
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/posix_features.hpp b/libktorrent/miniboost/boost/config/posix_features.hpp
new file mode 100644
index 00000000..d1295479
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/posix_features.hpp
@@ -0,0 +1,95 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org for most recent version.
+
+// All POSIX feature tests go in this file,
+// Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well
+// _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's
+// may be present but none-functional unless _POSIX_C_SOURCE and
+// _XOPEN_SOURCE have been defined to the right value (it's up
+// to the user to do this *before* including any header, although
+// in most cases the compiler will do this for you).
+
+#  if defined(BOOST_HAS_UNISTD_H)
+#     include 
+
+      // XOpen has , but is this the correct version check?
+#     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3)
+#        define BOOST_HAS_NL_TYPES_H
+#     endif
+
+      // POSIX version 6 requires 
+#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100)
+#        define BOOST_HAS_STDINT_H
+#     endif
+
+      // POSIX version 2 requires 
+#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L)
+#        define BOOST_HAS_DIRENT_H
+#     endif
+
+      // POSIX version 3 requires  to have sigaction:
+#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L)
+#        define BOOST_HAS_SIGACTION
+#     endif
+      // POSIX defines _POSIX_THREADS > 0 for pthread support,
+      // however some platforms define _POSIX_THREADS without
+      // a value, hence the (_POSIX_THREADS+0 >= 0) check.
+      // Strictly speaking this may catch platforms with a
+      // non-functioning stub , but such occurrences should
+      // occur very rarely if at all.
+#     if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS)
+#        define BOOST_HAS_PTHREADS
+#     endif
+
+      // BOOST_HAS_NANOSLEEP:
+      // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME:
+#     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \
+             || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
+#        define BOOST_HAS_NANOSLEEP
+#     endif
+
+      // BOOST_HAS_CLOCK_GETTIME:
+      // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME
+      // but at least one platform - linux - defines that flag without
+      // defining clock_gettime):
+#     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0))
+#        define BOOST_HAS_CLOCK_GETTIME
+#     endif
+
+      // BOOST_HAS_SCHED_YIELD:
+      // This is predicated on _POSIX_PRIORITY_SCHEDULING or
+      // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME.
+#     if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\
+            || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\
+            || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
+#        define BOOST_HAS_SCHED_YIELD
+#     endif
+
+      // BOOST_HAS_GETTIMEOFDAY:
+      // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE:
+      // These are predicated on _XOPEN_VERSION, and appears to be first released
+      // in issue 4, version 2 (_XOPEN_VERSION > 500).
+      // Likewise for the functions log1p and expm1.
+#     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500)
+#        define BOOST_HAS_GETTIMEOFDAY
+#        if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE+0 >= 500)
+#           define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#        endif
+#        ifndef BOOST_HAS_LOG1P
+#           define BOOST_HAS_LOG1P
+#        endif
+#        ifndef BOOST_HAS_EXPM1
+#           define BOOST_HAS_EXPM1
+#        endif
+#     endif
+
+#  endif
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/requires_threads.hpp b/libktorrent/miniboost/boost/config/requires_threads.hpp
new file mode 100644
index 00000000..cfaff230
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/requires_threads.hpp
@@ -0,0 +1,92 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_CONFIG_REQUIRES_THREADS_HPP
+#define BOOST_CONFIG_REQUIRES_THREADS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include 
+#endif
+
+#if defined(BOOST_DISABLE_THREADS)
+
+//
+// special case to handle versions of gcc which don't currently support threads:
+//
+#if defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC_MINOR__ <= 3) || !defined(BOOST_STRICT_CONFIG))
+//
+// this is checked up to gcc 3.3:
+//
+#if defined(__sgi) || defined(__hpux)
+#  error "Multi-threaded programs are not supported by gcc on HPUX or Irix (last checked with gcc 3.3)"
+#endif
+
+#endif
+
+#  error "Threading support unavaliable: it has been explicitly disabled with BOOST_DISABLE_THREADS"
+
+#elif !defined(BOOST_HAS_THREADS)
+
+# if defined __COMO__
+//  Comeau C++
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_MT (Windows) or -D_REENTRANT (Unix)"
+
+#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
+//  Intel
+#ifdef _WIN32
+#  error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd"
+#else
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -openmp"
+#endif
+
+# elif defined __GNUC__
+//  GNU C++:
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)"
+
+#elif defined __sgi
+//  SGI MIPSpro C++
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_SGI_MP_SOURCE"
+
+#elif defined __DECCXX
+//  Compaq Tru64 Unix cxx
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread"
+
+#elif defined __BORLANDC__
+//  Borland
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -tWM"
+
+#elif defined  __MWERKS__
+//  Metrowerks CodeWarrior
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: either -runtime sm, -runtime smd, -runtime dm, or -runtime dmd"
+
+#elif defined  __SUNPRO_CC
+//  Sun Workshop Compiler C++
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt"
+
+#elif defined __HP_aCC
+//  HP aCC
+#   error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt"
+
+#elif defined(__IBMCPP__)
+//  IBM Visual Age
+#   error "Compiler threading support is not turned on. Please compile the code with the xlC_r compiler"
+
+#elif defined _MSC_VER
+//  Microsoft Visual C++
+//
+//  Must remain the last #elif since some other vendors (Metrowerks, for
+//  example) also #define _MSC_VER
+#  error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd"
+
+#else
+
+#  error "Compiler threading support is not turned on.  Please consult your compiler's documentation for the appropriate options to use"
+
+#endif // compilers
+
+#endif // BOOST_HAS_THREADS
+
+#endif // BOOST_CONFIG_REQUIRES_THREADS_HPP
diff --git a/libktorrent/miniboost/boost/config/select_compiler_config.hpp b/libktorrent/miniboost/boost/config/select_compiler_config.hpp
new file mode 100644
index 00000000..62053ba0
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/select_compiler_config.hpp
@@ -0,0 +1,143 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Martin Wille 2003.
+//  (C) Copyright Guillaume Melquiond 2003.
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
+//   http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for most recent version.
+
+// locate which compiler we are using and define
+// BOOST_COMPILER_CONFIG as needed: 
+
+#if defined __CUDACC__
+//  NVIDIA CUDA C++ compiler for GPU
+#   include "boost/config/compiler/nvcc.hpp"
+
+#endif
+
+#if defined(__GCCXML__)
+// GCC-XML emulates other compilers, it has to appear first here!
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc_xml.hpp"
+
+#elif defined(_CRAYC)
+// EDG based Cray compiler:
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/cray.hpp"
+
+#elif defined __COMO__
+//  Comeau C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp"
+
+#elif defined(__PATHSCALE__) && (__PATHCC__ >= 4)
+// PathScale EKOPath compiler (has to come before clang and gcc)
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/pathscale.hpp"
+
+#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
+//  Intel
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"
+
+#elif defined __clang__
+//  Clang C++ emulates GCC, so it has to appear early.
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp"
+
+#elif defined __DMC__
+//  Digital Mars C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp"
+
+# elif defined __GNUC__
+//  GNU C++:
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
+
+#elif defined __KCC
+//  Kai C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp"
+
+#elif defined __sgi
+//  SGI MIPSpro C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp"
+
+#elif defined __DECCXX
+//  Compaq Tru64 Unix cxx
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp"
+
+#elif defined __ghs
+//  Greenhills C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp"
+
+#elif defined __CODEGEARC__
+//  CodeGear - must be checked for before Borland
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/codegear.hpp"
+
+#elif defined __BORLANDC__
+//  Borland
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp"
+
+#elif defined  __MWERKS__
+//  Metrowerks CodeWarrior
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp"
+
+#elif defined  __SUNPRO_CC
+//  Sun Workshop Compiler C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp"
+
+#elif defined __HP_aCC
+//  HP aCC
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp"
+
+#elif defined(__MRC__) || defined(__SC__)
+//  MPW MrCpp or SCpp
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp"
+
+#elif defined(__IBMCPP__)
+//  IBM Visual Age
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp"
+
+#elif defined(__PGI)
+//  Portland Group Inc.
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp"
+
+#elif defined _MSC_VER
+//  Microsoft Visual C++
+//
+//  Must remain the last #elif since some other vendors (Metrowerks, for
+//  example) also #define _MSC_VER
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp"
+
+#elif defined (BOOST_ASSERT_CONFIG)
+// this must come last - generate an error if we don't
+// recognise the compiler:
+#  error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)"
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the headers we *might* include:
+//
+#include "boost/config/compiler/gcc_xml.hpp"
+#include "boost/config/compiler/cray.hpp"
+#include "boost/config/compiler/comeau.hpp"
+#include "boost/config/compiler/pathscale.hpp"
+#include "boost/config/compiler/intel.hpp"
+#include "boost/config/compiler/clang.hpp"
+#include "boost/config/compiler/digitalmars.hpp"
+#include "boost/config/compiler/gcc.hpp"
+#include "boost/config/compiler/kai.hpp"
+#include "boost/config/compiler/sgi_mipspro.hpp"
+#include "boost/config/compiler/compaq_cxx.hpp"
+#include "boost/config/compiler/greenhills.hpp"
+#include "boost/config/compiler/codegear.hpp"
+#include "boost/config/compiler/borland.hpp"
+#include "boost/config/compiler/metrowerks.hpp"
+#include "boost/config/compiler/sunpro_cc.hpp"
+#include "boost/config/compiler/hp_acc.hpp"
+#include "boost/config/compiler/mpw.hpp"
+#include "boost/config/compiler/vacpp.hpp"
+#include "boost/config/compiler/pgi.hpp"
+#include "boost/config/compiler/visualc.hpp"
+
+#endif
+
diff --git a/libktorrent/miniboost/boost/config/select_platform_config.hpp b/libktorrent/miniboost/boost/config/select_platform_config.hpp
new file mode 100644
index 00000000..2dddc6a2
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/select_platform_config.hpp
@@ -0,0 +1,129 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  (C) Copyright Jens Maurer 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed.
+// Note that we define the headers to include using "header_name" not
+//  in order to prevent macro expansion within the header
+// name (for example "linux" is a macro on linux systems).
+
+#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
+// linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though?
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
+
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+// BSD:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp"
+
+#elif defined(sun) || defined(__sun)
+// solaris:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp"
+
+#elif defined(__sgi)
+// SGI Irix:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp"
+
+#elif defined(__hpux)
+// hp unix:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp"
+
+#elif defined(__CYGWIN__)
+// cygwin is not win32:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+// win32:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"
+
+#elif defined(__BEOS__)
+// BeOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"
+
+#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+// MacOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"
+
+#elif defined(__IBMCPP__) || defined(_AIX)
+// IBM
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"
+
+#elif defined(__amigaos__)
+// AmigaOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp"
+
+#elif defined(__QNXNTO__)
+// QNX:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp"
+
+#elif defined(__VXWORKS__)
+// vxWorks:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vxworks.hpp"
+
+#elif defined(__SYMBIAN32__) 
+// Symbian: 
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" 
+
+#elif defined(_CRAYC)
+// Cray:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cray.hpp" 
+
+#elif defined(__VMS) 
+// VMS:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 
+#else
+
+#  if defined(unix) \
+      || defined(__unix) \
+      || defined(_XOPEN_SOURCE) \
+      || defined(_POSIX_SOURCE)
+
+   // generic unix platform:
+
+#  ifndef BOOST_HAS_UNISTD_H
+#     define BOOST_HAS_UNISTD_H
+#  endif
+
+#  include 
+
+#  endif
+
+#  if defined (BOOST_ASSERT_CONFIG)
+      // this must come last - generate an error if we don't
+      // recognise the platform:
+#     error "Unknown platform - please configure and report the results to boost.org"
+#  endif
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+#  include "boost/config/platform/linux.hpp"
+#  include "boost/config/platform/bsd.hpp"
+#  include "boost/config/platform/solaris.hpp"
+#  include "boost/config/platform/irix.hpp"
+#  include "boost/config/platform/hpux.hpp"
+#  include "boost/config/platform/cygwin.hpp"
+#  include "boost/config/platform/win32.hpp"
+#  include "boost/config/platform/beos.hpp"
+#  include "boost/config/platform/macos.hpp"
+#  include "boost/config/platform/aix.hpp"
+#  include "boost/config/platform/amigaos.hpp"
+#  include "boost/config/platform/qnxnto.hpp"
+#  include "boost/config/platform/vxworks.hpp"
+#  include "boost/config/platform/symbian.hpp" 
+#  include "boost/config/platform/cray.hpp" 
+#  include "boost/config/platform/vms.hpp" 
+#  include 
+
+
+
+#endif
+
diff --git a/libktorrent/miniboost/boost/config/select_stdlib_config.hpp b/libktorrent/miniboost/boost/config/select_stdlib_config.hpp
new file mode 100644
index 00000000..6ae860b0
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/select_stdlib_config.hpp
@@ -0,0 +1,99 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2001 - 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org for most recent version.
+
+// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed:
+
+// First include  to determine if some version of STLport is in use as the std lib
+// (do not rely on this header being included since users can short-circuit this header 
+//  if they know whose std lib they are using.)
+#ifdef __cplusplus
+#  include 
+#else
+#  include 
+#endif
+
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+// STLPort library; this _must_ come first, otherwise since
+// STLport typically sits on top of some other library, we
+// can end up detecting that first rather than STLport:
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp"
+
+#else
+
+// If our std lib was not some version of STLport, then include  as it is about 
+// the smallest of the std lib headers that includes real C++ stuff.  (Some std libs do not
+// include their C++-related macros in  so this additional include makes sure
+// we get those definitions)
+// (again do not rely on this header being included since users can short-circuit this 
+//  header if they know whose std lib they are using.)
+#include 
+
+#if defined(__LIBCOMO__)
+// Comeau STL:
+#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp"
+
+#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// Rogue Wave library:
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp"
+
+#elif defined(_LIBCPP_VERSION)
+// libc++
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcpp.hpp"
+
+#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+// GNU libstdc++ 3
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
+
+#elif defined(__STL_CONFIG_H)
+// generic SGI STL
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp"
+
+#elif defined(__MSL_CPP__)
+// MSL standard lib:
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp"
+
+#elif defined(__IBMCPP__)
+// take the default VACPP std lib
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp"
+
+#elif defined(MSIPL_COMPILE_H)
+// Modena C++ standard library
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp"
+
+#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+// Dinkumware Library (this has to appear after any possible replacement libraries):
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp"
+
+#elif defined (BOOST_ASSERT_CONFIG)
+// this must come last - generate an error if we don't
+// recognise the library:
+#  error "Unknown standard library - please configure and report the results to boost.org"
+
+#endif
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+#  include "boost/config/stdlib/stlport.hpp"
+#  include "boost/config/stdlib/libcomo.hpp"
+#  include "boost/config/stdlib/roguewave.hpp"
+#  include "boost/config/stdlib/libcpp.hpp"
+#  include "boost/config/stdlib/libstdcpp3.hpp"
+#  include "boost/config/stdlib/sgi.hpp"
+#  include "boost/config/stdlib/msl.hpp"
+#  include "boost/config/stdlib/vacpp.hpp"
+#  include "boost/config/stdlib/modena.hpp"
+#  include "boost/config/stdlib/dinkumware.hpp"
+#endif
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/dinkumware.hpp b/libktorrent/miniboost/boost/config/stdlib/dinkumware.hpp
new file mode 100644
index 00000000..6fb6322a
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/dinkumware.hpp
@@ -0,0 +1,164 @@
+//  (C) Copyright John Maddock 2001 - 2003.
+//  (C) Copyright Jens Maurer 2001.
+//  (C) Copyright Peter Dimov 2001.
+//  (C) Copyright David Abrahams 2002.
+//  (C) Copyright Guillaume Melquiond 2003.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Dinkumware standard library config:
+
+#if !defined(_YVALS) && !defined(_CPPLIB_VER)
+#include 
+#if !defined(_YVALS) && !defined(_CPPLIB_VER)
+#error This is not the Dinkumware lib!
+#endif
+#endif
+
+
+#if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
+   // full dinkumware 3.06 and above
+   // fully conforming provided the compiler supports it:
+#  if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700))   // can be defined in yvals.h
+#     define BOOST_NO_STDC_NAMESPACE
+#  endif
+#  if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC)
+#     define BOOST_NO_STD_ALLOCATOR
+#  endif
+#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+#  if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+      // if this lib version is set up for vc6 then there is no std::use_facet:
+#     define BOOST_NO_STD_USE_FACET
+#     define BOOST_HAS_TWO_ARG_USE_FACET
+      // C lib functions aren't in namespace std either:
+#     define BOOST_NO_STDC_NAMESPACE
+      // and nor is 
+#     define BOOST_NO_EXCEPTION_STD_NAMESPACE
+#  endif
+// There's no numeric_limits support unless _LONGLONG is defined:
+#  if !defined(_LONGLONG) && (_CPPLIB_VER <= 310)
+#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#  endif
+// 3.06 appears to have (non-sgi versions of)  & ,
+// and no  at all
+#else
+#  define BOOST_MSVC_STD_ITERATOR 1
+#  define BOOST_NO_STD_ITERATOR
+#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+#  define BOOST_NO_STD_ALLOCATOR
+#  define BOOST_NO_STDC_NAMESPACE
+#  define BOOST_NO_STD_USE_FACET
+#  define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
+#  define BOOST_HAS_MACRO_USE_FACET
+#  ifndef _CPPLIB_VER
+      // Updated Dinkum library defines this, and provides
+      // its own min and max definitions, as does MTA version.
+#     ifndef __MTA__ 
+#        define BOOST_NO_STD_MIN_MAX
+#     endif
+#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#  endif
+#endif
+
+//
+// std extension namespace is stdext for vc7.1 and later, 
+// the same applies to other compilers that sit on top
+// of vc7.1 (Intel and Comeau):
+//
+#if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__)
+#  define BOOST_STD_EXTENSION_NAMESPACE stdext
+#endif
+
+
+#if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306)
+   // if we're using a dinkum lib that's
+   // been configured for VC6/7 then there is
+   // no iterator traits (true even for icl)
+#  define BOOST_NO_STD_ITERATOR_TRAITS
+#endif
+
+#if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310)
+// Intel C++ chokes over any non-trivial use of 
+// this may be an overly restrictive define, but regex fails without it:
+#  define BOOST_NO_STD_LOCALE
+#endif
+
+// Fix for VC++ 8.0 on up ( I do not have a previous version to test )
+// or clang-cl. If exceptions are off you must manually include the 
+//  header before including the  header. Admittedly 
+// trying to use Boost libraries or the standard C++ libraries without 
+// exception support is not suggested but currently clang-cl ( v 3.4 ) 
+// does not support exceptions and must be compiled with exceptions off.
+#if !_HAS_EXCEPTIONS && ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER)))
+#include 
+#endif
+#include 
+#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) && !defined(__TI_COMPILER_VERSION__)
+#  define BOOST_NO_STD_TYPEINFO
+#endif  
+
+//  C++0x headers implemented in 520 (as shipped by Microsoft)
+//
+#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 520
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_SMART_PTR
+#endif
+
+#if ((!defined(_HAS_TR1_IMPORTS) || (_HAS_TR1_IMPORTS+0 == 0)) && !defined(BOOST_NO_CXX11_HDR_TUPLE)) \
+  && (!defined(_CPPLIB_VER) || _CPPLIB_VER < 610)
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#endif
+
+//  C++0x headers implemented in 540 (as shipped by Microsoft)
+//
+#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 540
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#endif
+
+//  C++0x headers implemented in 610 (as shipped by Microsoft)
+//
+#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 610
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_ALLOCATOR
+// 540 has std::align but it is not a conforming implementation
+#  define BOOST_NO_CXX11_STD_ALIGN
+#endif
+
+//  520..610 have std::addressof, but it doesn't support functions
+//
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+#ifdef _CPPLIB_VER
+#  define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
+#else
+#  define BOOST_DINKUMWARE_STDLIB 1
+#endif
+
+#ifdef _CPPLIB_VER
+#  define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER)
+#else
+#  define BOOST_STDLIB "Dinkumware standard library version 1.x"
+#endif
diff --git a/libktorrent/miniboost/boost/config/stdlib/libcomo.hpp b/libktorrent/miniboost/boost/config/stdlib/libcomo.hpp
new file mode 100644
index 00000000..5aacfb2a
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/libcomo.hpp
@@ -0,0 +1,75 @@
+//  (C) Copyright John Maddock 2002 - 2003. 
+//  (C) Copyright Jens Maurer 2002 - 2003. 
+//  (C) Copyright Beman Dawes 2002 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Comeau STL:
+
+#if !defined(__LIBCOMO__)
+#  include 
+#  if !defined(__LIBCOMO__)
+#      error "This is not the Comeau STL!"
+#  endif
+#endif
+
+//
+// std::streambuf is non-standard
+// NOTE: versions of libcomo prior to beta28 have octal version numbering,
+// e.g. version 25 is 21 (dec)
+#if __LIBCOMO_VERSION__ <= 22
+#  define BOOST_NO_STD_WSTREAMBUF
+#endif
+
+#if (__LIBCOMO_VERSION__ <= 31) && defined(_WIN32)
+#define BOOST_NO_SWPRINTF
+#endif
+
+#if __LIBCOMO_VERSION__ >= 31
+#  define BOOST_HAS_HASH
+#  define BOOST_HAS_SLIST
+#endif
+
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+//
+// Intrinsic type_traits support.
+// The SGI STL has it's own __type_traits class, which
+// has intrinsic compiler support with SGI's compilers.
+// Whatever map SGI style type traits to boost equivalents:
+//
+#define BOOST_HAS_SGI_TYPE_TRAITS
+
+#define BOOST_STDLIB "Comeau standard library " BOOST_STRINGIZE(__LIBCOMO_VERSION__)
+
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/libcpp.hpp b/libktorrent/miniboost/boost/config/stdlib/libcpp.hpp
new file mode 100644
index 00000000..88184ef9
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/libcpp.hpp
@@ -0,0 +1,46 @@
+//  (C) Copyright Christopher Jefferson 2011.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  config for libc++
+//  Might need more in here later.
+
+#if !defined(_LIBCPP_VERSION)
+#  include 
+#  if !defined(_LIBCPP_VERSION)
+#      error "This is not libc++!"
+#  endif
+#endif
+
+#define BOOST_STDLIB "libc++ version " BOOST_STRINGIZE(_LIBCPP_VERSION)
+
+#define BOOST_HAS_THREADS
+
+#ifdef _LIBCPP_HAS_NO_VARIADICS
+#    define BOOST_NO_CXX11_HDR_TUPLE
+#endif
+
+// BOOST_NO_CXX11_ALLOCATOR should imply no support for the C++11
+// allocator model. The C++11 allocator model requires a conforming
+// std::allocator_traits which is only possible with C++11 template
+// aliases since members rebind_alloc and rebind_traits require it.
+#if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES)
+#    define BOOST_NO_CXX11_ALLOCATOR
+#endif
+
+//
+// These appear to be unusable/incomplete so far:
+//
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+
+// libc++ uses a non-standard messages_base
+#define BOOST_NO_STD_MESSAGES
+
+//  --- end ---
diff --git a/libktorrent/miniboost/boost/config/stdlib/libstdcpp3.hpp b/libktorrent/miniboost/boost/config/stdlib/libstdcpp3.hpp
new file mode 100644
index 00000000..2fd6ea7d
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/libstdcpp3.hpp
@@ -0,0 +1,178 @@
+//  (C) Copyright John Maddock 2001.
+//  (C) Copyright Jens Maurer 2001.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  config for libstdc++ v3
+//  not much to go in here:
+
+#define BOOST_GNU_STDLIB 1
+
+#ifdef __GLIBCXX__
+#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
+#else
+#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCPP__)
+#endif
+
+#if !defined(_GLIBCPP_USE_WCHAR_T) && !defined(_GLIBCXX_USE_WCHAR_T)
+#  define BOOST_NO_CWCHAR
+#  define BOOST_NO_CWCTYPE
+#  define BOOST_NO_STD_WSTRING
+#  define BOOST_NO_STD_WSTREAMBUF
+#endif
+
+#if defined(__osf__) && !defined(_REENTRANT) \
+  && ( defined(_GLIBCXX_HAVE_GTHR_DEFAULT) || defined(_GLIBCPP_HAVE_GTHR_DEFAULT) )
+// GCC 3 on Tru64 forces the definition of _REENTRANT when any std lib header
+// file is included, therefore for consistency we define it here as well.
+#  define _REENTRANT
+#endif
+
+#ifdef __GLIBCXX__ // gcc 3.4 and greater:
+#  if defined(_GLIBCXX_HAVE_GTHR_DEFAULT) \
+        || defined(_GLIBCXX__PTHREADS) \
+        || defined(_GLIBCXX_HAS_GTHREADS) \
+        || defined(_WIN32) \
+        || defined(_AIX)
+      //
+      // If the std lib has thread support turned on, then turn it on in Boost
+      // as well.  We do this because some gcc-3.4 std lib headers define _REENTANT
+      // while others do not...
+      //
+#     define BOOST_HAS_THREADS
+#  else
+#     define BOOST_DISABLE_THREADS
+#  endif
+#elif defined(__GLIBCPP__) \
+        && !defined(_GLIBCPP_HAVE_GTHR_DEFAULT) \
+        && !defined(_GLIBCPP__PTHREADS)
+   // disable thread support if the std lib was built single threaded:
+#  define BOOST_DISABLE_THREADS
+#endif
+
+#if (defined(linux) || defined(__linux) || defined(__linux__)) && defined(__arm__) && defined(_GLIBCPP_HAVE_GTHR_DEFAULT)
+// linux on arm apparently doesn't define _REENTRANT
+// so just turn on threading support whenever the std lib is thread safe:
+#  define BOOST_HAS_THREADS
+#endif
+
+#if !defined(_GLIBCPP_USE_LONG_LONG) \
+    && !defined(_GLIBCXX_USE_LONG_LONG)\
+    && defined(BOOST_HAS_LONG_LONG)
+// May have been set by compiler/*.hpp, but "long long" without library
+// support is useless.
+#  undef BOOST_HAS_LONG_LONG
+#endif
+
+// Apple doesn't seem to reliably defined a *unix* macro
+#if !defined(CYGWIN) && (  defined(__unix__)  \
+                        || defined(__unix)    \
+                        || defined(unix)      \
+                        || defined(__APPLE__) \
+                        || defined(__APPLE)   \
+                        || defined(APPLE))
+#  include 
+#endif
+
+#if defined(__GLIBCXX__) || (defined(__GLIBCPP__) && __GLIBCPP__>=20020514) // GCC >= 3.1.0
+#  define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
+#  define BOOST_HAS_SLIST
+#  define BOOST_HAS_HASH
+#  define BOOST_SLIST_HEADER 
+# if !defined(__GNUC__) || __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)
+#   define BOOST_HASH_SET_HEADER 
+#   define BOOST_HASH_MAP_HEADER 
+# else
+#   define BOOST_HASH_SET_HEADER 
+#   define BOOST_HASH_MAP_HEADER 
+# endif
+#endif
+
+//  stdlibc++ C++0x support is detected via __GNUC__, __GNUC_MINOR__, and possibly
+//  __GNUC_PATCHLEVEL__ at the suggestion of Jonathan Wakely, one of the stdlibc++
+//  developers. He also commented:
+//
+//       "I'm not sure how useful __GLIBCXX__ is for your purposes, for instance in
+//       GCC 4.2.4 it is set to 20080519 but in GCC 4.3.0 it is set to 20080305.
+//       Although 4.3.0 was released earlier than 4.2.4, it has better C++0x support
+//       than any release in the 4.2 series."
+//
+//  Another resource for understanding stdlibc++ features is:
+//  http://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#manual.intro.status.standard.200x
+
+//  C++0x headers in GCC 4.3.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#endif
+
+//  C++0x headers in GCC 4.4.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_SMART_PTR
+#else
+#  define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG 
+#  define BOOST_HAS_TR1_COMPLEX_OVERLOADS 
+#endif
+
+#if (!defined(_GLIBCXX_HAS_GTHREADS) || !defined(_GLIBCXX_USE_C99_STDINT_TR1)) && (!defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) || !defined(BOOST_NO_CXX11_HDR_MUTEX))
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#endif
+
+//  C++0x features in GCC 4.5.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#endif
+
+//  C++0x features in GCC 4.6.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_ADDRESSOF
+#endif
+
+//  C++0x features in GCC 4.7.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+// Note that although  existed prior to 4.7, "steady_clock" is spelled "monotonic_clock"
+// so 4.7.0 is the first truely conforming one.
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_ALLOCATOR
+#endif
+//  C++0x features in GCC 4.7.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+// Note that although  existed prior to gcc 4.8 it was largely unimplemented for many types:
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#endif
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+// Although  is present and compilable against, the actual implementation is not functional
+// even for the simplest patterns such as "\d" or "[0-9]". This is the case at least in gcc up to 4.8, inclusively.
+#  define BOOST_NO_CXX11_HDR_REGEX
+#endif
+//  C++0x headers not yet (fully!) implemented
+//
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_STD_ALIGN
+
+//  --- end ---
diff --git a/libktorrent/miniboost/boost/config/stdlib/modena.hpp b/libktorrent/miniboost/boost/config/stdlib/modena.hpp
new file mode 100644
index 00000000..f2a83888
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/modena.hpp
@@ -0,0 +1,59 @@
+//  (C) Copyright Jens Maurer 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Modena C++ standard library (comes with KAI C++)
+
+#if !defined(MSIPL_COMPILE_H)
+#  include 
+#  if !defined(__MSIPL_COMPILE_H)
+#      error "This is not the Modena C++ library!"
+#  endif
+#endif
+
+#ifndef MSIPL_NL_TYPES
+#define BOOST_NO_STD_MESSAGES
+#endif
+
+#ifndef MSIPL_WCHART
+#define BOOST_NO_STD_WSTRING
+#endif
+
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+#define BOOST_STDLIB "Modena C++ standard library"
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/msl.hpp b/libktorrent/miniboost/boost/config/stdlib/msl.hpp
new file mode 100644
index 00000000..b8f43a12
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/msl.hpp
@@ -0,0 +1,87 @@
+//  (C) Copyright John Maddock 2001. 
+//  (C) Copyright Darin Adler 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Metrowerks standard library:
+
+#ifndef __MSL_CPP__
+#  include 
+#  ifndef __MSL_CPP__
+#     error This is not the MSL standard library!
+#  endif
+#endif
+
+#if __MSL_CPP__ >= 0x6000  // Pro 6
+#  define BOOST_HAS_HASH
+#  define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
+#endif
+#define BOOST_HAS_SLIST
+
+#if __MSL_CPP__ < 0x6209
+#  define BOOST_NO_STD_MESSAGES
+#endif
+
+// check C lib version for 
+#include 
+
+#if defined(__MSL__) && (__MSL__ >= 0x5000)
+#  define BOOST_HAS_STDINT_H
+#  if !defined(__PALMOS_TRAPS__)
+#    define BOOST_HAS_UNISTD_H
+#  endif
+   // boilerplate code:
+#  include 
+#endif
+
+#if defined(_MWMT) || _MSL_THREADSAFE
+#  define BOOST_HAS_THREADS
+#endif
+
+#ifdef _MSL_NO_EXPLICIT_FUNC_TEMPLATE_ARG
+#  define BOOST_NO_STD_USE_FACET
+#  define BOOST_HAS_TWO_ARG_USE_FACET
+#endif
+
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+#define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
+
+
+
+
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/roguewave.hpp b/libktorrent/miniboost/boost/config/stdlib/roguewave.hpp
new file mode 100644
index 00000000..2b4e8636
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/roguewave.hpp
@@ -0,0 +1,189 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2001. 
+//  (C) Copyright David Abrahams 2003. 
+//  (C) Copyright Boris Gubenko 2007. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  Rogue Wave std lib:
+
+#define BOOST_RW_STDLIB 1 
+
+#if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)
+#  include 
+#  if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)
+#     error This is not the Rogue Wave standard library
+#  endif
+#endif
+//
+// figure out a consistent version number:
+//
+#ifndef _RWSTD_VER
+#  define BOOST_RWSTD_VER 0x010000
+#elif _RWSTD_VER < 0x010000
+#  define BOOST_RWSTD_VER (_RWSTD_VER << 8)
+#else
+#  define BOOST_RWSTD_VER _RWSTD_VER
+#endif
+
+#ifndef _RWSTD_VER
+#  define BOOST_STDLIB "Rogue Wave standard library version (Unknown version)"
+#elif _RWSTD_VER < 0x04010200
+ #  define BOOST_STDLIB "Rogue Wave standard library version " BOOST_STRINGIZE(_RWSTD_VER)
+#else
+#  ifdef _RWSTD_VER_STR
+#    define BOOST_STDLIB "Apache STDCXX standard library version " _RWSTD_VER_STR
+#  else
+#    define BOOST_STDLIB "Apache STDCXX standard library version " BOOST_STRINGIZE(_RWSTD_VER)
+#  endif
+#endif
+
+//
+// Prior to version 2.2.0 the primary template for std::numeric_limits
+// does not have compile time constants, even though specializations of that
+// template do:
+//
+#if BOOST_RWSTD_VER < 0x020200
+#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#endif
+
+// Sun CC 5.5 patch 113817-07 adds long long specialization, but does not change the
+// library version number (http://sunsolve6.sun.com/search/document.do?assetkey=1-21-113817):
+#if BOOST_RWSTD_VER <= 0x020101 && (!defined(__SUNPRO_CC) || (__SUNPRO_CC < 0x550))
+#  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
+# endif
+
+//
+// Borland version of numeric_limits lacks __int64 specialisation:
+//
+#ifdef __BORLANDC__
+#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#endif
+
+//
+// No std::iterator if it can't figure out default template args:
+//
+#if defined(_RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || defined(RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || (BOOST_RWSTD_VER < 0x020000)
+#  define BOOST_NO_STD_ITERATOR
+#endif
+
+//
+// No iterator traits without partial specialization:
+//
+#if defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) || defined(RWSTD_NO_CLASS_PARTIAL_SPEC)
+#  define BOOST_NO_STD_ITERATOR_TRAITS
+#endif
+
+//
+// Prior to version 2.0, std::auto_ptr was buggy, and there were no
+// new-style iostreams, and no conformant std::allocator:
+//
+#if (BOOST_RWSTD_VER < 0x020000)
+#  define BOOST_NO_AUTO_PTR
+#  define BOOST_NO_STRINGSTREAM
+#  define BOOST_NO_STD_ALLOCATOR
+#  define BOOST_NO_STD_LOCALE
+#endif
+
+//
+// No template iterator constructors without member template support:
+//
+#if defined(RWSTD_NO_MEMBER_TEMPLATES) || defined(_RWSTD_NO_MEMBER_TEMPLATES)
+#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+#endif
+
+//
+// RW defines _RWSTD_ALLOCATOR if the allocator is conformant and in use
+// (the or _HPACC_ part is a hack - the library seems to define _RWSTD_ALLOCATOR
+// on HP aCC systems even though the allocator is in fact broken):
+//
+#if !defined(_RWSTD_ALLOCATOR) || (defined(__HP_aCC) && __HP_aCC <= 33100)
+#  define BOOST_NO_STD_ALLOCATOR
+#endif
+
+//
+// If we have a std::locale, we still may not have std::use_facet:
+//
+#if defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined(BOOST_NO_STD_LOCALE)
+#  define BOOST_NO_STD_USE_FACET
+#  define BOOST_HAS_TWO_ARG_USE_FACET
+#endif
+
+//
+// There's no std::distance prior to version 2, or without
+// partial specialization support:
+//
+#if (BOOST_RWSTD_VER < 0x020000) || defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
+    #define BOOST_NO_STD_DISTANCE
+#endif
+
+//
+// Some versions of the rogue wave library don't have assignable
+// OutputIterators:
+//
+#if BOOST_RWSTD_VER < 0x020100
+#  define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
+#endif
+
+//
+// Disable BOOST_HAS_LONG_LONG when the library has no support for it.
+//
+#if !defined(_RWSTD_LONG_LONG) && defined(BOOST_HAS_LONG_LONG)
+#  undef BOOST_HAS_LONG_LONG
+#endif
+
+//
+// check that on HP-UX, the proper RW library is used
+//
+#if defined(__HP_aCC) && !defined(_HP_NAMESPACE_STD)
+#  error "Boost requires Standard RW library. Please compile and link with -AA"
+#endif
+
+//
+// Define macros specific to RW V2.2 on HP-UX
+//
+#if defined(__HP_aCC) && (BOOST_RWSTD_VER == 0x02020100)
+#  ifndef __HP_TC1_MAKE_PAIR
+#    define __HP_TC1_MAKE_PAIR
+#  endif
+#  ifndef _HP_INSTANTIATE_STD2_VL
+#    define _HP_INSTANTIATE_STD2_VL
+#  endif
+#endif
+
+#if _RWSTD_VER < 0x05000000
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#endif
+// type_traits header is incomplete:
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+//
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/sgi.hpp b/libktorrent/miniboost/boost/config/stdlib/sgi.hpp
new file mode 100644
index 00000000..bda77c22
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/sgi.hpp
@@ -0,0 +1,151 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Darin Adler 2001. 
+//  (C) Copyright Jens Maurer 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  generic SGI STL:
+
+#if !defined(__STL_CONFIG_H)
+#  include 
+#  if !defined(__STL_CONFIG_H)
+#      error "This is not the SGI STL!"
+#  endif
+#endif
+
+//
+// No std::iterator traits without partial specialisation:
+//
+#if !defined(__STL_CLASS_PARTIAL_SPECIALIZATION)
+#  define BOOST_NO_STD_ITERATOR_TRAITS
+#endif
+
+//
+// No std::stringstream with gcc < 3
+//
+#if defined(__GNUC__) && (__GNUC__ < 3) && \
+     ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)) && \
+     !defined(__STL_USE_NEW_IOSTREAMS) || \
+   defined(__APPLE_CC__)
+   // Note that we only set this for GNU C++ prior to 2.95 since the
+   // latest patches for that release do contain a minimal 
+   // If you are running a 2.95 release prior to 2.95.3 then this will need
+   // setting, but there is no way to detect that automatically (other
+   // than by running the configure script).
+   // Also, the unofficial GNU C++ 2.96 included in RedHat 7.1 doesn't
+   // have .
+#  define BOOST_NO_STRINGSTREAM
+#endif
+
+// Apple doesn't seem to reliably defined a *unix* macro
+#if !defined(CYGWIN) && (  defined(__unix__)  \
+                        || defined(__unix)    \
+                        || defined(unix)      \
+                        || defined(__APPLE__) \
+                        || defined(__APPLE)   \
+                        || defined(APPLE))
+#  include 
+#endif
+
+
+//
+// Assume no std::locale without own iostreams (this may be an
+// incorrect assumption in some cases):
+//
+#if !defined(__SGI_STL_OWN_IOSTREAMS) && !defined(__STL_USE_NEW_IOSTREAMS)
+#  define BOOST_NO_STD_LOCALE
+#endif
+
+//
+// Original native SGI streams have non-standard std::messages facet:
+//
+#if defined(__sgi) && (_COMPILER_VERSION <= 650) && !defined(__SGI_STL_OWN_IOSTREAMS)
+#  define BOOST_NO_STD_LOCALE
+#endif
+
+//
+// SGI's new iostreams have missing "const" in messages<>::open
+//
+#if defined(__sgi) && (_COMPILER_VERSION <= 740) && defined(__STL_USE_NEW_IOSTREAMS)
+#  define BOOST_NO_STD_MESSAGES
+#endif
+
+//
+// No template iterator constructors, or std::allocator
+// without member templates:
+//
+#if !defined(__STL_MEMBER_TEMPLATES)
+#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+#  define BOOST_NO_STD_ALLOCATOR
+#endif
+
+//
+// We always have SGI style hash_set, hash_map, and slist:
+//
+#define BOOST_HAS_HASH
+#define BOOST_HAS_SLIST
+
+//
+// If this is GNU libstdc++2, then no  and no std::wstring:
+//
+#if (defined(__GNUC__) && (__GNUC__ < 3))
+#  include 
+#  if defined(__BASTRING__)
+#     define BOOST_NO_LIMITS
+// Note:  will provide compile-time constants
+#     undef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#     define BOOST_NO_STD_WSTRING
+#  endif
+#endif
+
+//
+// There is no standard iterator unless we have namespace support:
+//
+#if !defined(__STL_USE_NAMESPACES)
+#  define BOOST_NO_STD_ITERATOR
+#endif
+
+//
+// Intrinsic type_traits support.
+// The SGI STL has it's own __type_traits class, which
+// has intrinsic compiler support with SGI's compilers.
+// Whatever map SGI style type traits to boost equivalents:
+//
+#define BOOST_HAS_SGI_TYPE_TRAITS
+
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+#define BOOST_STDLIB "SGI standard library"
+
+
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/stlport.hpp b/libktorrent/miniboost/boost/config/stdlib/stlport.hpp
new file mode 100644
index 00000000..fd5d3a5a
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/stlport.hpp
@@ -0,0 +1,246 @@
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  (C) Copyright Darin Adler 2001. 
+//  (C) Copyright Jens Maurer 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+//  STLPort standard library config:
+
+#if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#  include 
+#  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#      error "This is not STLPort!"
+#  endif
+#endif
+
+// Apple doesn't seem to reliably defined a *unix* macro
+#if !defined(CYGWIN) && (  defined(__unix__)  \
+                        || defined(__unix)    \
+                        || defined(unix)      \
+                        || defined(__APPLE__) \
+                        || defined(__APPLE)   \
+                        || defined(APPLE))
+#  include 
+#endif
+
+//
+// __STL_STATIC_CONST_INIT_BUG implies BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+// for versions prior to 4.1(beta)
+//
+#if (defined(__STL_STATIC_CONST_INIT_BUG) || defined(_STLP_STATIC_CONST_INIT_BUG)) && (__SGI_STL_PORT <= 0x400)
+#  define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#endif
+
+//
+// If STLport thinks that there is no partial specialisation, then there is no
+// std::iterator traits:
+//
+#if !(defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined(__STL_CLASS_PARTIAL_SPECIALIZATION))
+#  define BOOST_NO_STD_ITERATOR_TRAITS
+#endif
+
+//
+// No new style iostreams on GCC without STLport's iostreams enabled:
+//
+#if (defined(__GNUC__) && (__GNUC__ < 3)) && !(defined(__SGI_STL_OWN_IOSTREAMS) || defined(_STLP_OWN_IOSTREAMS))
+#  define BOOST_NO_STRINGSTREAM
+#endif
+
+//
+// No new iostreams implies no std::locale, and no std::stringstream:
+//
+#if defined(__STL_NO_IOSTREAMS) || defined(__STL_NO_NEW_IOSTREAMS) || defined(_STLP_NO_IOSTREAMS) || defined(_STLP_NO_NEW_IOSTREAMS)
+#  define BOOST_NO_STD_LOCALE
+#  define BOOST_NO_STRINGSTREAM
+#endif
+
+//
+// If the streams are not native, and we have a "using ::x" compiler bug
+// then the io stream facets are not available in namespace std::
+//
+#ifdef _STLPORT_VERSION
+#  if !(_STLPORT_VERSION >= 0x500) && !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__)
+#     define BOOST_NO_STD_LOCALE
+#  endif
+#else
+#  if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__)
+#     define BOOST_NO_STD_LOCALE
+#  endif
+#endif
+
+#if defined(_STLPORT_VERSION) && (_STLPORT_VERSION >= 0x520)
+#  define BOOST_HAS_TR1_UNORDERED_SET
+#  define BOOST_HAS_TR1_UNORDERED_MAP
+#endif
+//
+// Without member template support enabled, their are no template
+// iterate constructors, and no std::allocator:
+//
+#if !(defined(__STL_MEMBER_TEMPLATES) || defined(_STLP_MEMBER_TEMPLATES))
+#  define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+#  define BOOST_NO_STD_ALLOCATOR
+#endif
+//
+// however we always have at least a partial allocator:
+//
+#define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+
+#if !defined(_STLP_MEMBER_TEMPLATE_CLASSES) || defined(_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+#  define BOOST_NO_STD_ALLOCATOR
+#endif
+
+#if defined(_STLP_NO_MEMBER_TEMPLATE_KEYWORD) && defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
+#  define BOOST_NO_STD_ALLOCATOR
+#endif
+
+//
+// If STLport thinks there is no wchar_t at all, then we have to disable
+// the support for the relevant specilazations of std:: templates.
+//
+#if !defined(_STLP_HAS_WCHAR_T) && !defined(_STLP_WCHAR_T_IS_USHORT)
+#  ifndef  BOOST_NO_STD_WSTRING
+#     define BOOST_NO_STD_WSTRING
+#  endif
+#  ifndef  BOOST_NO_STD_WSTREAMBUF
+#     define BOOST_NO_STD_WSTREAMBUF
+#  endif
+#endif
+
+//
+// We always have SGI style hash_set, hash_map, and slist:
+//
+#ifndef _STLP_NO_EXTENSIONS
+#define BOOST_HAS_HASH
+#define BOOST_HAS_SLIST
+#endif
+
+//
+// STLport does a good job of importing names into namespace std::,
+// but doesn't always get them all, define BOOST_NO_STDC_NAMESPACE, since our
+// workaround does not conflict with STLports:
+//
+//
+// Harold Howe says:
+// Borland switched to STLport in BCB6. Defining BOOST_NO_STDC_NAMESPACE with
+// BCB6 does cause problems. If we detect C++ Builder, then don't define 
+// BOOST_NO_STDC_NAMESPACE
+//
+#if !defined(__BORLANDC__) && !defined(__DMC__)
+//
+// If STLport is using it's own namespace, and the real names are in
+// the global namespace, then we duplicate STLport's using declarations
+// (by defining BOOST_NO_STDC_NAMESPACE), we do this because STLport doesn't
+// necessarily import all the names we need into namespace std::
+// 
+#  if (defined(__STL_IMPORT_VENDOR_CSTD) \
+         || defined(__STL_USE_OWN_NAMESPACE) \
+         || defined(_STLP_IMPORT_VENDOR_CSTD) \
+         || defined(_STLP_USE_OWN_NAMESPACE)) \
+      && (defined(__STL_VENDOR_GLOBAL_CSTD) || defined (_STLP_VENDOR_GLOBAL_CSTD))
+#     define BOOST_NO_STDC_NAMESPACE
+#     define BOOST_NO_EXCEPTION_STD_NAMESPACE
+#  endif
+#elif defined(__BORLANDC__) && __BORLANDC__ < 0x560
+// STLport doesn't import std::abs correctly:
+#include 
+namespace std { using ::abs; }
+// and strcmp/strcpy don't get imported either ('cos they are macros)
+#include 
+#ifdef strcpy
+#  undef strcpy
+#endif
+#ifdef strcmp
+#  undef strcmp
+#endif
+#ifdef _STLP_VENDOR_CSTD
+namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD::strcpy; }
+#endif
+#endif
+
+//
+// std::use_facet may be non-standard, uses a class instead:
+//
+#if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) || defined(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
+#  define BOOST_NO_STD_USE_FACET
+#  define BOOST_HAS_STLP_USE_FACET
+#endif
+
+//
+// If STLport thinks there are no wide functions,  etc. is not working; but
+// only if BOOST_NO_STDC_NAMESPACE is not defined (if it is then we do the import 
+// into std:: ourselves).
+//
+#if defined(_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined(BOOST_NO_STDC_NAMESPACE)
+#  define BOOST_NO_CWCHAR
+#  define BOOST_NO_CWCTYPE
+#endif
+
+//
+// If STLport for some reason was configured so that it thinks that wchar_t
+// is not an intrinsic type, then we have to disable the support for it as
+// well (we would be missing required specializations otherwise).
+//
+#if !defined( _STLP_HAS_WCHAR_T) || defined(_STLP_WCHAR_T_IS_USHORT)
+#  undef  BOOST_NO_INTRINSIC_WCHAR_T
+#  define BOOST_NO_INTRINSIC_WCHAR_T
+#endif
+
+//
+// Borland ships a version of STLport with C++ Builder 6 that lacks
+// hashtables and the like:
+//
+#if defined(__BORLANDC__) && (__BORLANDC__ == 0x560)
+#  undef BOOST_HAS_HASH
+#endif
+
+//
+// gcc-2.95.3/STLPort does not like the using declarations we use to get ADL with std::min/max
+//
+#if defined(__GNUC__) && (__GNUC__ < 3)
+#  include  // for std::min and std::max
+#  define BOOST_USING_STD_MIN() ((void)0)
+#  define BOOST_USING_STD_MAX() ((void)0)
+namespace boost { using std::min; using std::max; }
+#endif
+
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+#define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)
+
+
+
+
+
+
+
+
diff --git a/libktorrent/miniboost/boost/config/stdlib/vacpp.hpp b/libktorrent/miniboost/boost/config/stdlib/vacpp.hpp
new file mode 100644
index 00000000..a58ec1c5
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/stdlib/vacpp.hpp
@@ -0,0 +1,57 @@
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+#if __IBMCPP__ <= 501
+#  define BOOST_NO_STD_ALLOCATOR
+#endif
+
+#define BOOST_HAS_MACRO_USE_FACET
+#define BOOST_NO_STD_MESSAGES
+
+// Apple doesn't seem to reliably defined a *unix* macro
+#if !defined(CYGWIN) && (  defined(__unix__)  \
+                        || defined(__unix)    \
+                        || defined(unix)      \
+                        || defined(__APPLE__) \
+                        || defined(__APPLE)   \
+                        || defined(APPLE))
+#  include 
+#endif
+
+//  C++0x headers not yet implemented
+//
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CODECVT
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_RANDOM
+#  define BOOST_NO_CXX11_HDR_RATIO
+#  define BOOST_NO_CXX11_HDR_REGEX
+#  define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#  define BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_TUPLE
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#  define BOOST_NO_CXX11_NUMERIC_LIMITS
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#  define BOOST_NO_CXX11_SMART_PTR
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_ADDRESSOF
+
+#define BOOST_STDLIB "Visual Age default standard library"
+
+
+
diff --git a/libktorrent/miniboost/boost/config/suffix.hpp b/libktorrent/miniboost/boost/config/suffix.hpp
new file mode 100644
index 00000000..a3fda525
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/suffix.hpp
@@ -0,0 +1,971 @@
+//  Boost config.hpp configuration header file  ------------------------------//
+//	boostinspect:ndprecated_macros	-- tell the inspect tool to ignore this file
+
+//  Copyright (c) 2001-2003 John Maddock
+//  Copyright (c) 2001 Darin Adler
+//  Copyright (c) 2001 Peter Dimov
+//  Copyright (c) 2002 Bill Kempf
+//  Copyright (c) 2002 Jens Maurer
+//  Copyright (c) 2002-2003 David Abrahams
+//  Copyright (c) 2003 Gennaro Prota
+//  Copyright (c) 2003 Eric Friedman
+//  Copyright (c) 2010 Eric Jourdanneau, Joel Falcou
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for most recent version.
+
+//  Boost config.hpp policy and rationale documentation has been moved to
+//  http://www.boost.org/libs/config/
+//
+//  This file is intended to be stable, and relatively unchanging.
+//  It should contain boilerplate code only - no compiler specific
+//  code unless it is unavoidable - no changes unless unavoidable.
+
+#ifndef BOOST_CONFIG_SUFFIX_HPP
+#define BOOST_CONFIG_SUFFIX_HPP
+
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+//
+// Some GCC-4.x versions issue warnings even when __extension__ is used,
+// so use this as a workaround:
+//
+#pragma GCC system_header
+#endif
+
+//
+// ensure that visibility macros are always defined, thus symplifying use
+//
+#ifndef BOOST_SYMBOL_EXPORT
+# define BOOST_SYMBOL_EXPORT
+#endif
+#ifndef BOOST_SYMBOL_IMPORT
+# define BOOST_SYMBOL_IMPORT
+#endif
+#ifndef BOOST_SYMBOL_VISIBLE
+# define BOOST_SYMBOL_VISIBLE
+#endif
+
+//
+// look for long long by looking for the appropriate macros in .
+// Note that we use limits.h rather than climits for maximal portability,
+// remember that since these just declare a bunch of macros, there should be
+// no namespace issues from this.
+//
+#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG)                                              \
+   && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
+# include 
+# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
+#   define BOOST_HAS_LONG_LONG
+# else
+#   define BOOST_NO_LONG_LONG
+# endif
+#endif
+
+// GCC 3.x will clean up all of those nasty macro definitions that
+// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
+// it under GCC 3.x.
+#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS)
+#  undef BOOST_NO_CTYPE_FUNCTIONS
+#endif
+
+//
+// Assume any extensions are in namespace std:: unless stated otherwise:
+//
+#  ifndef BOOST_STD_EXTENSION_NAMESPACE
+#    define BOOST_STD_EXTENSION_NAMESPACE std
+#  endif
+
+//
+// If cv-qualified specializations are not allowed, then neither are cv-void ones:
+//
+#  if defined(BOOST_NO_CV_SPECIALIZATIONS) \
+      && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
+#     define BOOST_NO_CV_VOID_SPECIALIZATIONS
+#  endif
+
+//
+// If there is no numeric_limits template, then it can't have any compile time
+// constants either!
+//
+#  if defined(BOOST_NO_LIMITS) \
+      && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
+#     define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#     define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
+#  endif
+
+//
+// if there is no long long then there is no specialisation
+// for numeric_limits either:
+//
+#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
+#  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
+#endif
+
+//
+// if there is no __int64 then there is no specialisation
+// for numeric_limits<__int64> either:
+//
+#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)
+#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#endif
+
+//
+// if member templates are supported then so is the
+// VC6 subset of member templates:
+//
+#  if !defined(BOOST_NO_MEMBER_TEMPLATES) \
+       && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#     define BOOST_MSVC6_MEMBER_TEMPLATES
+#  endif
+
+//
+// Without partial specialization, can't test for partial specialisation bugs:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
+#     define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
+#  endif
+
+//
+// Without partial specialization, we can't have array-type partial specialisations:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#     define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
+#  endif
+
+//
+// Without partial specialization, std::iterator_traits can't work:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+#     define BOOST_NO_STD_ITERATOR_TRAITS
+#  endif
+
+//
+// Without partial specialization, partial
+// specialization with default args won't work either:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
+#     define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+#  endif
+
+//
+// Without member template support, we can't have template constructors
+// in the standard library either:
+//
+#  if defined(BOOST_NO_MEMBER_TEMPLATES) \
+      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
+      && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
+#     define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+#  endif
+
+//
+// Without member template support, we can't have a conforming
+// std::allocator template either:
+//
+#  if defined(BOOST_NO_MEMBER_TEMPLATES) \
+      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
+      && !defined(BOOST_NO_STD_ALLOCATOR)
+#     define BOOST_NO_STD_ALLOCATOR
+#  endif
+
+//
+// without ADL support then using declarations will break ADL as well:
+//
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#endif
+
+//
+// Without typeid support we have no dynamic RTTI either:
+//
+#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
+#  define BOOST_NO_RTTI
+#endif
+
+//
+// If we have a standard allocator, then we have a partial one as well:
+//
+#if !defined(BOOST_NO_STD_ALLOCATOR)
+#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+#endif
+
+//
+// We can't have a working std::use_facet if there is no std::locale:
+//
+#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET)
+#     define BOOST_NO_STD_USE_FACET
+#  endif
+
+//
+// We can't have a std::messages facet if there is no std::locale:
+//
+#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES)
+#     define BOOST_NO_STD_MESSAGES
+#  endif
+
+//
+// We can't have a working std::wstreambuf if there is no std::locale:
+//
+#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
+#     define BOOST_NO_STD_WSTREAMBUF
+#  endif
+
+//
+// We can't have a  if there is no :
+//
+#  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE)
+#     define BOOST_NO_CWCTYPE
+#  endif
+
+//
+// We can't have a swprintf if there is no :
+//
+#  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
+#     define BOOST_NO_SWPRINTF
+#  endif
+
+//
+// If Win32 support is turned off, then we must turn off
+// threading support also, unless there is some other
+// thread API enabled:
+//
+#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \
+   && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS)
+#  define BOOST_DISABLE_THREADS
+#endif
+
+//
+// Turn on threading support if the compiler thinks that it's in
+// multithreaded mode.  We put this here because there are only a
+// limited number of macros that identify this (if there's any missing
+// from here then add to the appropriate compiler section):
+//
+#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
+    || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \
+    && !defined(BOOST_HAS_THREADS)
+#  define BOOST_HAS_THREADS
+#endif
+
+//
+// Turn threading support off if BOOST_DISABLE_THREADS is defined:
+//
+#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS)
+#  undef BOOST_HAS_THREADS
+#endif
+
+//
+// Turn threading support off if we don't recognise the threading API:
+//
+#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\
+      && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\
+      && !defined(BOOST_HAS_MPTASKS)
+#  undef BOOST_HAS_THREADS
+#endif
+
+//
+// Turn threading detail macros off if we don't (want to) use threading
+//
+#ifndef BOOST_HAS_THREADS
+#  undef BOOST_HAS_PTHREADS
+#  undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  undef BOOST_HAS_PTHREAD_YIELD
+#  undef BOOST_HAS_PTHREAD_DELAY_NP
+#  undef BOOST_HAS_WINTHREADS
+#  undef BOOST_HAS_BETHREADS
+#  undef BOOST_HAS_MPTASKS
+#endif
+
+//
+// If the compiler claims to be C99 conformant, then it had better
+// have a :
+//
+#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+#     define BOOST_HAS_STDINT_H
+#     ifndef BOOST_HAS_LOG1P
+#        define BOOST_HAS_LOG1P
+#     endif
+#     ifndef BOOST_HAS_EXPM1
+#        define BOOST_HAS_EXPM1
+#     endif
+#  endif
+
+//
+// Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
+// Note that this is for backwards compatibility only.
+//
+#  if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST)
+#     define BOOST_NO_SLIST
+#  endif
+
+#  if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH)
+#     define BOOST_NO_HASH
+#  endif
+
+//
+// Set BOOST_SLIST_HEADER if not set already:
+//
+#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER)
+#  define BOOST_SLIST_HEADER 
+#endif
+
+//
+// Set BOOST_HASH_SET_HEADER if not set already:
+//
+#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER)
+#  define BOOST_HASH_SET_HEADER 
+#endif
+
+//
+// Set BOOST_HASH_MAP_HEADER if not set already:
+//
+#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER)
+#  define BOOST_HASH_MAP_HEADER 
+#endif
+
+//  BOOST_HAS_ABI_HEADERS
+//  This macro gets set if we have headers that fix the ABI,
+//  and prevent ODR violations when linking to external libraries:
+#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS)
+#  define BOOST_HAS_ABI_HEADERS
+#endif
+
+#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS)
+#  undef BOOST_HAS_ABI_HEADERS
+#endif
+
+//  BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
+//  Because std::size_t usage is so common, even in boost headers which do not
+//  otherwise use the C library, the  workaround is included here so
+//  that ugly workaround code need not appear in many other boost headers.
+//  NOTE WELL: This is a workaround for non-conforming compilers; 
+//  must still be #included in the usual places so that  inclusion
+//  works as expected with standard conforming compilers.  The resulting
+//  double inclusion of  is harmless.
+
+# if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus)
+#   include 
+    namespace std { using ::ptrdiff_t; using ::size_t; }
+# endif
+
+//  Workaround for the unfortunate min/max macros defined by some platform headers
+
+#define BOOST_PREVENT_MACRO_SUBSTITUTION
+
+#ifndef BOOST_USING_STD_MIN
+#  define BOOST_USING_STD_MIN() using std::min
+#endif
+
+#ifndef BOOST_USING_STD_MAX
+#  define BOOST_USING_STD_MAX() using std::max
+#endif
+
+//  BOOST_NO_STD_MIN_MAX workaround  -----------------------------------------//
+
+#  if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus)
+
+namespace std {
+  template 
+  inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
+    return __b < __a ? __b : __a;
+  }
+  template 
+  inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
+    return  __a < __b ? __b : __a;
+  }
+}
+
+#  endif
+
+// BOOST_STATIC_CONSTANT workaround --------------------------------------- //
+// On compilers which don't allow in-class initialization of static integral
+// constant members, we must use enums as a workaround if we want the constants
+// to be available at compile-time. This macro gives us a convenient way to
+// declare such constants.
+
+#  ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+#       define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
+#  else
+#     define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
+#  endif
+
+// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
+// When the standard library does not have a conforming std::use_facet there
+// are various workarounds available, but they differ from library to library.
+// The same problem occurs with has_facet.
+// These macros provide a consistent way to access a locale's facets.
+// Usage:
+//    replace
+//       std::use_facet(loc);
+//    with
+//       BOOST_USE_FACET(Type, loc);
+//    Note do not add a std:: prefix to the front of BOOST_USE_FACET!
+//  Use for BOOST_HAS_FACET is analogous.
+
+#if defined(BOOST_NO_STD_USE_FACET)
+#  ifdef BOOST_HAS_TWO_ARG_USE_FACET
+#     define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast(0))
+#     define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast(0))
+#  elif defined(BOOST_HAS_MACRO_USE_FACET)
+#     define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
+#     define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
+#  elif defined(BOOST_HAS_STLP_USE_FACET)
+#     define BOOST_USE_FACET(Type, loc) (*std::_Use_facet(loc))
+#     define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
+#  endif
+#else
+#  define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
+#  define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
+#endif
+
+// BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
+// Member templates are supported by some compilers even though they can't use
+// the A::template member syntax, as a workaround replace:
+//
+// typedef typename A::template rebind binder;
+//
+// with:
+//
+// typedef typename A::BOOST_NESTED_TEMPLATE rebind binder;
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
+#  define BOOST_NESTED_TEMPLATE template
+#else
+#  define BOOST_NESTED_TEMPLATE
+#endif
+
+// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
+// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION
+// is defined, in which case it evaluates to return x; Use when you have a return
+// statement that can never be reached.
+
+#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
+#  define BOOST_UNREACHABLE_RETURN(x) return x;
+#else
+#  define BOOST_UNREACHABLE_RETURN(x)
+#endif
+
+// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
+//
+// Some compilers don't support the use of `typename' for dependent
+// types in deduced contexts, e.g.
+//
+//     template  void f(T, typename T::type);
+//                                  ^^^^^^^^
+// Replace these declarations with:
+//
+//     template  void f(T, BOOST_DEDUCED_TYPENAME T::type);
+
+#ifndef BOOST_NO_DEDUCED_TYPENAME
+#  define BOOST_DEDUCED_TYPENAME typename
+#else
+#  define BOOST_DEDUCED_TYPENAME
+#endif
+
+#ifndef BOOST_NO_TYPENAME_WITH_CTOR
+#  define BOOST_CTOR_TYPENAME typename
+#else
+#  define BOOST_CTOR_TYPENAME
+#endif
+
+// long long workaround ------------------------------------------//
+// On gcc (and maybe other compilers?) long long is alway supported
+// but it's use may generate either warnings (with -ansi), or errors
+// (with -pedantic -ansi) unless it's use is prefixed by __extension__
+//
+#if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus)
+namespace boost{
+#  ifdef __GNUC__
+   __extension__ typedef long long long_long_type;
+   __extension__ typedef unsigned long long ulong_long_type;
+#  else
+   typedef long long long_long_type;
+   typedef unsigned long long ulong_long_type;
+#  endif
+}
+#endif
+// same again for __int128:
+#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
+namespace boost{
+#  ifdef __GNUC__
+   __extension__ typedef __int128 int128_type;
+   __extension__ typedef unsigned __int128 uint128_type;
+#  else
+   typedef __int128 int128_type;
+   typedef unsigned __int128 uint128_type;
+#  endif
+}
+#endif
+
+// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
+
+// These macros are obsolete. Port away and remove.
+
+#  define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
+#  define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
+#  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
+#  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
+
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
+
+// When BOOST_NO_STD_TYPEINFO is defined, we can just import
+// the global definition into std namespace:
+#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus)
+#include 
+namespace std{ using ::type_info; }
+#endif
+
+// ---------------------------------------------------------------------------//
+
+//
+// Helper macro BOOST_STRINGIZE:
+// Converts the parameter X to a string after macro replacement
+// on X has been performed.
+//
+#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
+#define BOOST_DO_STRINGIZE(X) #X
+
+//
+// Helper macro BOOST_JOIN:
+// The following piece of macro magic joins the two
+// arguments together, even when one of the arguments is
+// itself a macro (see 16.3.1 in C++ standard).  The key
+// is that macro expansion of macro arguments does not
+// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN.
+//
+#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
+#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
+#define BOOST_DO_JOIN2( X, Y ) X##Y
+
+//
+// Set some default values for compiler/library/platform names.
+// These are for debugging config setup only:
+//
+#  ifndef BOOST_COMPILER
+#     define BOOST_COMPILER "Unknown ISO C++ Compiler"
+#  endif
+#  ifndef BOOST_STDLIB
+#     define BOOST_STDLIB "Unknown ISO standard library"
+#  endif
+#  ifndef BOOST_PLATFORM
+#     if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
+         || defined(_POSIX_SOURCE)
+#        define BOOST_PLATFORM "Generic Unix"
+#     else
+#        define BOOST_PLATFORM "Unknown"
+#     endif
+#  endif
+
+//
+// Set some default values GPU support
+//
+#  ifndef BOOST_GPU_ENABLED
+#  define BOOST_GPU_ENABLED
+#  endif
+
+// BOOST_FORCEINLINE ---------------------------------------------//
+// Macro to use in place of 'inline' to force a function to be inline
+#if !defined(BOOST_FORCEINLINE)
+#  if defined(_MSC_VER)
+#    define BOOST_FORCEINLINE __forceinline
+#  elif defined(__GNUC__) && __GNUC__ > 3
+     // Clang also defines __GNUC__ (as 4)
+#    define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
+#  else
+#    define BOOST_FORCEINLINE inline
+#  endif
+#endif
+
+// BOOST_NOINLINE ---------------------------------------------//
+// Macro to use in place of 'inline' to prevent a function to be inlined
+#if !defined(BOOST_NOINLINE)
+#  if defined(_MSC_VER)
+#    define BOOST_NOINLINE __declspec(noinline)
+#  elif defined(__GNUC__) && __GNUC__ > 3
+     // Clang also defines __GNUC__ (as 4)
+#    if defined(__CUDACC__)
+       // nvcc doesn't always parse __noinline__, 
+       // see: https://svn.boost.org/trac/boost/ticket/9392
+#      define BOOST_NOINLINE __attribute__ ((noinline))
+#    else
+#      define BOOST_NOINLINE __attribute__ ((__noinline__))
+#    endif
+#  else
+#    define BOOST_NOINLINE
+#  endif
+#endif
+
+// BOOST_NORETURN ---------------------------------------------//
+// Macro to use before a function declaration/definition to designate
+// the function as not returning normally (i.e. with a return statement
+// or by leaving the function scope, if the function return type is void).
+#if !defined(BOOST_NORETURN)
+#  if defined(_MSC_VER)
+#    define BOOST_NORETURN __declspec(noreturn)
+#  elif defined(__GNUC__)
+#    define BOOST_NORETURN __attribute__ ((__noreturn__))
+#  else
+#    define BOOST_NO_NORETURN
+#    define BOOST_NORETURN
+#  endif
+#endif
+
+// Branch prediction hints
+// These macros are intended to wrap conditional expressions that yield true or false
+//
+//  if (BOOST_LIKELY(var == 10))
+//  {
+//     // the most probable code here
+//  }
+//
+#if !defined(BOOST_LIKELY)
+#  define BOOST_LIKELY(x) x
+#endif
+#if !defined(BOOST_UNLIKELY)
+#  define BOOST_UNLIKELY(x) x
+#endif
+
+// Type and data alignment specification
+//
+#if !defined(BOOST_NO_CXX11_ALIGNAS)
+#  define BOOST_ALIGNMENT(x) alignas(x)
+#elif defined(_MSC_VER)
+#  define BOOST_ALIGNMENT(x) __declspec(align(x))
+#elif defined(__GNUC__)
+#  define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x)))
+#else
+#  define BOOST_NO_ALIGNMENT
+#  define BOOST_ALIGNMENT(x)
+#endif
+
+// Defaulted and deleted function declaration helpers
+// These macros are intended to be inside a class definition.
+// BOOST_DEFAULTED_FUNCTION accepts the function declaration and its
+// body, which will be used if the compiler doesn't support defaulted functions.
+// BOOST_DELETED_FUNCTION only accepts the function declaration. It
+// will expand to a private function declaration, if the compiler doesn't support
+// deleted functions. Because of this it is recommended to use BOOST_DELETED_FUNCTION
+// in the end of the class definition.
+//
+//  class my_class
+//  {
+//  public:
+//      // Default-constructible
+//      BOOST_DEFAULTED_FUNCTION(my_class(), {})
+//      // Copying prohibited
+//      BOOST_DELETED_FUNCTION(my_class(my_class const&))
+//      BOOST_DELETED_FUNCTION(my_class& operator= (my_class const&))
+//  };
+//
+#if !(defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS))
+#   define BOOST_DEFAULTED_FUNCTION(fun, body) fun = default;
+#else
+#   define BOOST_DEFAULTED_FUNCTION(fun, body) fun body
+#endif
+
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+#   define BOOST_DELETED_FUNCTION(fun) fun = delete;
+#else
+#   define BOOST_DELETED_FUNCTION(fun) private: fun;
+#endif
+
+//
+// Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined
+//
+#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#define	BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE
+#endif
+
+//  -------------------- Deprecated macros for 1.50 ---------------------------
+//  These will go away in a future release
+
+//  Use BOOST_NO_CXX11_HDR_UNORDERED_SET or BOOST_NO_CXX11_HDR_UNORDERED_MAP
+//           instead of BOOST_NO_STD_UNORDERED
+#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) || defined (BOOST_NO_CXX11_HDR_UNORDERED_SET)
+# ifndef BOOST_NO_CXX11_STD_UNORDERED
+#  define BOOST_NO_CXX11_STD_UNORDERED
+# endif
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST instead of BOOST_NO_INITIALIZER_LISTS
+#if defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS)
+#  define BOOST_NO_INITIALIZER_LISTS
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_ARRAY instead of BOOST_NO_0X_HDR_ARRAY
+#if defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_0X_HDR_ARRAY)
+#  define BOOST_NO_0X_HDR_ARRAY
+#endif
+//  Use BOOST_NO_CXX11_HDR_CHRONO instead of BOOST_NO_0X_HDR_CHRONO
+#if defined(BOOST_NO_CXX11_HDR_CHRONO) && !defined(BOOST_NO_0X_HDR_CHRONO)
+#  define BOOST_NO_0X_HDR_CHRONO
+#endif
+//  Use BOOST_NO_CXX11_HDR_CODECVT instead of BOOST_NO_0X_HDR_CODECVT
+#if defined(BOOST_NO_CXX11_HDR_CODECVT) && !defined(BOOST_NO_0X_HDR_CODECVT)
+#  define BOOST_NO_0X_HDR_CODECVT
+#endif
+//  Use BOOST_NO_CXX11_HDR_CONDITION_VARIABLE instead of BOOST_NO_0X_HDR_CONDITION_VARIABLE
+#if defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) && !defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE)
+#  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
+#endif
+//  Use BOOST_NO_CXX11_HDR_FORWARD_LIST instead of BOOST_NO_0X_HDR_FORWARD_LIST
+#if defined(BOOST_NO_CXX11_HDR_FORWARD_LIST) && !defined(BOOST_NO_0X_HDR_FORWARD_LIST)
+#  define BOOST_NO_0X_HDR_FORWARD_LIST
+#endif
+//  Use BOOST_NO_CXX11_HDR_FUTURE instead of BOOST_NO_0X_HDR_FUTURE
+#if defined(BOOST_NO_CXX11_HDR_FUTURE) && !defined(BOOST_NO_0X_HDR_FUTURE)
+#  define BOOST_NO_0X_HDR_FUTURE
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+//  instead of BOOST_NO_0X_HDR_INITIALIZER_LIST or BOOST_NO_INITIALIZER_LISTS
+#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+# ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST
+#  define BOOST_NO_0X_HDR_INITIALIZER_LIST
+# endif
+# ifndef BOOST_NO_INITIALIZER_LISTS
+#  define BOOST_NO_INITIALIZER_LISTS
+# endif
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_MUTEX instead of BOOST_NO_0X_HDR_MUTEX
+#if defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX)
+#  define BOOST_NO_0X_HDR_MUTEX
+#endif
+//  Use BOOST_NO_CXX11_HDR_RANDOM instead of BOOST_NO_0X_HDR_RANDOM
+#if defined(BOOST_NO_CXX11_HDR_RANDOM) && !defined(BOOST_NO_0X_HDR_RANDOM)
+#  define BOOST_NO_0X_HDR_RANDOM
+#endif
+//  Use BOOST_NO_CXX11_HDR_RATIO instead of BOOST_NO_0X_HDR_RATIO
+#if defined(BOOST_NO_CXX11_HDR_RATIO) && !defined(BOOST_NO_0X_HDR_RATIO)
+#  define BOOST_NO_0X_HDR_RATIO
+#endif
+//  Use BOOST_NO_CXX11_HDR_REGEX instead of BOOST_NO_0X_HDR_REGEX
+#if defined(BOOST_NO_CXX11_HDR_REGEX) && !defined(BOOST_NO_0X_HDR_REGEX)
+#  define BOOST_NO_0X_HDR_REGEX
+#endif
+//  Use BOOST_NO_CXX11_HDR_SYSTEM_ERROR instead of BOOST_NO_0X_HDR_SYSTEM_ERROR
+#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_0X_HDR_SYSTEM_ERROR)
+#  define BOOST_NO_0X_HDR_SYSTEM_ERROR
+#endif
+//  Use BOOST_NO_CXX11_HDR_THREAD instead of BOOST_NO_0X_HDR_THREAD
+#if defined(BOOST_NO_CXX11_HDR_THREAD) && !defined(BOOST_NO_0X_HDR_THREAD)
+#  define BOOST_NO_0X_HDR_THREAD
+#endif
+//  Use BOOST_NO_CXX11_HDR_TUPLE instead of BOOST_NO_0X_HDR_TUPLE
+#if defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_0X_HDR_TUPLE)
+#  define BOOST_NO_0X_HDR_TUPLE
+#endif
+//  Use BOOST_NO_CXX11_HDR_TYPE_TRAITS instead of BOOST_NO_0X_HDR_TYPE_TRAITS
+#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+#  define BOOST_NO_0X_HDR_TYPE_TRAITS
+#endif
+//  Use BOOST_NO_CXX11_HDR_TYPEINDEX instead of BOOST_NO_0X_HDR_TYPEINDEX
+#if defined(BOOST_NO_CXX11_HDR_TYPEINDEX) && !defined(BOOST_NO_0X_HDR_TYPEINDEX)
+#  define BOOST_NO_0X_HDR_TYPEINDEX
+#endif
+//  Use BOOST_NO_CXX11_HDR_UNORDERED_MAP instead of BOOST_NO_0X_HDR_UNORDERED_MAP
+#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) && !defined(BOOST_NO_0X_HDR_UNORDERED_MAP)
+#  define BOOST_NO_0X_HDR_UNORDERED_MAP
+#endif
+//  Use BOOST_NO_CXX11_HDR_UNORDERED_SET instead of BOOST_NO_0X_HDR_UNORDERED_SET
+#if defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_NO_0X_HDR_UNORDERED_SET)
+#  define BOOST_NO_0X_HDR_UNORDERED_SET
+#endif
+
+//  ------------------ End of deprecated macros for 1.50 ---------------------------
+
+//  -------------------- Deprecated macros for 1.51 ---------------------------
+//  These will go away in a future release
+
+//  Use     BOOST_NO_CXX11_AUTO_DECLARATIONS instead of   BOOST_NO_AUTO_DECLARATIONS
+#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_AUTO_DECLARATIONS)
+#  define BOOST_NO_AUTO_DECLARATIONS
+#endif
+//  Use     BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS instead of   BOOST_NO_AUTO_MULTIDECLARATIONS
+#if defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS) && !defined(BOOST_NO_AUTO_MULTIDECLARATIONS)
+#  define BOOST_NO_AUTO_MULTIDECLARATIONS
+#endif
+//  Use     BOOST_NO_CXX11_CHAR16_T instead of   BOOST_NO_CHAR16_T
+#if defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CHAR16_T)
+#  define BOOST_NO_CHAR16_T
+#endif
+//  Use     BOOST_NO_CXX11_CHAR32_T instead of   BOOST_NO_CHAR32_T
+#if defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CHAR32_T)
+#  define BOOST_NO_CHAR32_T
+#endif
+//  Use     BOOST_NO_CXX11_TEMPLATE_ALIASES instead of   BOOST_NO_TEMPLATE_ALIASES
+#if defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_TEMPLATE_ALIASES)
+#  define BOOST_NO_TEMPLATE_ALIASES
+#endif
+//  Use     BOOST_NO_CXX11_CONSTEXPR instead of   BOOST_NO_CONSTEXPR
+#if defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CONSTEXPR)
+#  define BOOST_NO_CONSTEXPR
+#endif
+//  Use     BOOST_NO_CXX11_DECLTYPE_N3276 instead of   BOOST_NO_DECLTYPE_N3276
+#if defined(BOOST_NO_CXX11_DECLTYPE_N3276) && !defined(BOOST_NO_DECLTYPE_N3276)
+#  define BOOST_NO_DECLTYPE_N3276
+#endif
+//  Use     BOOST_NO_CXX11_DECLTYPE instead of   BOOST_NO_DECLTYPE
+#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE)
+#  define BOOST_NO_DECLTYPE
+#endif
+//  Use     BOOST_NO_CXX11_DEFAULTED_FUNCTIONS instead of   BOOST_NO_DEFAULTED_FUNCTIONS
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS)
+#  define BOOST_NO_DEFAULTED_FUNCTIONS
+#endif
+//  Use     BOOST_NO_CXX11_DELETED_FUNCTIONS instead of   BOOST_NO_DELETED_FUNCTIONS
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_DELETED_FUNCTIONS)
+#  define BOOST_NO_DELETED_FUNCTIONS
+#endif
+//  Use     BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS instead of   BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && !defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
+#  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#endif
+//  Use     BOOST_NO_CXX11_EXTERN_TEMPLATE instead of   BOOST_NO_EXTERN_TEMPLATE
+#if defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) && !defined(BOOST_NO_EXTERN_TEMPLATE)
+#  define BOOST_NO_EXTERN_TEMPLATE
+#endif
+//  Use     BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS instead of   BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+#  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+//  Use     BOOST_NO_CXX11_LAMBDAS instead of   BOOST_NO_LAMBDAS
+#if defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS)
+#  define BOOST_NO_LAMBDAS
+#endif
+//  Use     BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS instead of   BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#if defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS) && !defined(BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS)
+#  define BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#endif
+//  Use     BOOST_NO_CXX11_NOEXCEPT instead of   BOOST_NO_NOEXCEPT
+#if defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_NOEXCEPT)
+#  define BOOST_NO_NOEXCEPT
+#endif
+//  Use     BOOST_NO_CXX11_NULLPTR instead of   BOOST_NO_NULLPTR
+#if defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR)
+#  define BOOST_NO_NULLPTR
+#endif
+//  Use     BOOST_NO_CXX11_RAW_LITERALS instead of   BOOST_NO_RAW_LITERALS
+#if defined(BOOST_NO_CXX11_RAW_LITERALS) && !defined(BOOST_NO_RAW_LITERALS)
+#  define BOOST_NO_RAW_LITERALS
+#endif
+//  Use     BOOST_NO_CXX11_RVALUE_REFERENCES instead of   BOOST_NO_RVALUE_REFERENCES
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES)
+#  define BOOST_NO_RVALUE_REFERENCES
+#endif
+//  Use     BOOST_NO_CXX11_SCOPED_ENUMS instead of   BOOST_NO_SCOPED_ENUMS
+#if defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_NO_SCOPED_ENUMS)
+#  define BOOST_NO_SCOPED_ENUMS
+#endif
+//  Use     BOOST_NO_CXX11_STATIC_ASSERT instead of   BOOST_NO_STATIC_ASSERT
+#if defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_NO_STATIC_ASSERT)
+#  define BOOST_NO_STATIC_ASSERT
+#endif
+//  Use     BOOST_NO_CXX11_STD_UNORDERED instead of   BOOST_NO_STD_UNORDERED
+#if defined(BOOST_NO_CXX11_STD_UNORDERED) && !defined(BOOST_NO_STD_UNORDERED)
+#  define BOOST_NO_STD_UNORDERED
+#endif
+//  Use     BOOST_NO_CXX11_UNICODE_LITERALS instead of   BOOST_NO_UNICODE_LITERALS
+#if defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(BOOST_NO_UNICODE_LITERALS)
+#  define BOOST_NO_UNICODE_LITERALS
+#endif
+//  Use     BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX instead of   BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
+#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX)
+#  define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
+#endif
+//  Use     BOOST_NO_CXX11_VARIADIC_TEMPLATES instead of   BOOST_NO_VARIADIC_TEMPLATES
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#  define BOOST_NO_VARIADIC_TEMPLATES
+#endif
+//  Use     BOOST_NO_CXX11_VARIADIC_MACROS instead of   BOOST_NO_VARIADIC_MACROS
+#if defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS)
+#  define BOOST_NO_VARIADIC_MACROS
+#endif
+//  Use     BOOST_NO_CXX11_NUMERIC_LIMITS instead of   BOOST_NO_NUMERIC_LIMITS_LOWEST
+#if defined(BOOST_NO_CXX11_NUMERIC_LIMITS) && !defined(BOOST_NO_NUMERIC_LIMITS_LOWEST)
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
+#endif
+//  ------------------ End of deprecated macros for 1.51 ---------------------------
+
+
+
+//
+// Helper macros BOOST_NOEXCEPT, BOOST_NOEXCEPT_IF, BOOST_NOEXCEPT_EXPR
+// These aid the transition to C++11 while still supporting C++03 compilers
+//
+#ifdef BOOST_NO_CXX11_NOEXCEPT
+#  define BOOST_NOEXCEPT
+#  define BOOST_NOEXCEPT_OR_NOTHROW throw()
+#  define BOOST_NOEXCEPT_IF(Predicate)
+#  define BOOST_NOEXCEPT_EXPR(Expression) false
+#else
+#  define BOOST_NOEXCEPT noexcept
+#  define BOOST_NOEXCEPT_OR_NOTHROW noexcept
+#  define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
+#  define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
+#endif
+//
+// Helper macro BOOST_FALLTHROUGH
+// Fallback definition of BOOST_FALLTHROUGH macro used to mark intended
+// fall-through between case labels in a switch statement. We use a definition
+// that requires a semicolon after it to avoid at least one type of misuse even
+// on unsupported compilers.
+//
+#ifndef BOOST_FALLTHROUGH
+#  define BOOST_FALLTHROUGH ((void)0)
+#endif
+
+//
+// constexpr workarounds
+//
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+#define BOOST_CONSTEXPR
+#define BOOST_CONSTEXPR_OR_CONST const
+#else
+#define BOOST_CONSTEXPR constexpr
+#define BOOST_CONSTEXPR_OR_CONST constexpr
+#endif
+
+#define BOOST_STATIC_CONSTEXPR  static BOOST_CONSTEXPR_OR_CONST
+
+//
+// Set BOOST_HAS_STATIC_ASSERT when BOOST_NO_CXX11_STATIC_ASSERT is not defined
+//
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT)
+#  define BOOST_HAS_STATIC_ASSERT
+#endif
+
+//
+// Set BOOST_HAS_RVALUE_REFS when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
+//
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS)
+#define BOOST_HAS_RVALUE_REFS
+#endif
+
+//
+// Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_CXX11_VARIADIC_TEMPLATES is not defined
+//
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL)
+#define BOOST_HAS_VARIADIC_TMPL
+#endif
+
+//
+// Finish off with checks for macros that are depricated / no longer supported,
+// if any of these are set then it's very likely that much of Boost will no
+// longer work.  So stop with a #error for now, but give the user a chance
+// to continue at their own risk if they really want to:
+//
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED)
+#  error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!"
+#endif
+
+#endif
diff --git a/libktorrent/miniboost/boost/config/user.hpp b/libktorrent/miniboost/boost/config/user.hpp
new file mode 100644
index 00000000..d226a2d1
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/user.hpp
@@ -0,0 +1,123 @@
+//  boost/config/user.hpp  ---------------------------------------------------//
+
+//  (C) Copyright John Maddock 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  Do not check in modified versions of this file,
+//  This file may be customized by the end user, but not by boost.
+
+//
+//  Use this file to define a site and compiler specific
+//  configuration policy:
+//
+
+// define this to locate a compiler config file:
+// #define BOOST_COMPILER_CONFIG 
+
+// define this to locate a stdlib config file:
+// #define BOOST_STDLIB_CONFIG   
+
+// define this to locate a platform config file:
+// #define BOOST_PLATFORM_CONFIG 
+
+// define this to disable compiler config,
+// use if your compiler config has nothing to set:
+// #define BOOST_NO_COMPILER_CONFIG
+
+// define this to disable stdlib config,
+// use if your stdlib config has nothing to set:
+// #define BOOST_NO_STDLIB_CONFIG
+
+// define this to disable platform config,
+// use if your platform config has nothing to set:
+// #define BOOST_NO_PLATFORM_CONFIG
+
+// define this to disable all config options,
+// excluding the user config.  Use if your
+// setup is fully ISO compliant, and has no
+// useful extensions, or for autoconf generated
+// setups:
+// #define BOOST_NO_CONFIG
+
+// define this to make the config "optimistic"
+// about unknown compiler versions.  Normally
+// unknown compiler versions are assumed to have
+// all the defects of the last known version, however
+// setting this flag, causes the config to assume
+// that unknown compiler versions are fully conformant
+// with the standard:
+// #define BOOST_STRICT_CONFIG
+
+// define this to cause the config to halt compilation
+// with an #error if it encounters anything unknown --
+// either an unknown compiler version or an unknown
+// compiler/platform/library:
+// #define BOOST_ASSERT_CONFIG
+
+
+// define if you want to disable threading support, even
+// when available:
+// #define BOOST_DISABLE_THREADS
+
+// define when you want to disable Win32 specific features
+// even when available:
+// #define BOOST_DISABLE_WIN32
+
+// BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any 
+// prefix/suffix headers that normally control things like struct 
+// packing and alignment. 
+// #define BOOST_DISABLE_ABI_HEADERS
+
+// BOOST_ABI_PREFIX: A prefix header to include in place of whatever
+// boost.config would normally select, any replacement should set up 
+// struct packing and alignment options as required. 
+// #define BOOST_ABI_PREFIX my-header-name
+
+// BOOST_ABI_SUFFIX: A suffix header to include in place of whatever 
+// boost.config would normally select, any replacement should undo 
+// the effects of the prefix header. 
+// #define BOOST_ABI_SUFFIX my-header-name
+
+// BOOST_ALL_DYN_LINK: Forces all libraries that have separate source, 
+// to be linked as dll's rather than static libraries on Microsoft Windows 
+// (this macro is used to turn on __declspec(dllimport) modifiers, so that 
+// the compiler knows which symbols to look for in a dll rather than in a 
+// static library).  Note that there may be some libraries that can only 
+// be linked in one way (statically or dynamically), in these cases this 
+// macro has no effect.
+// #define BOOST_ALL_DYN_LINK
+ 
+// BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll 
+// rather than a static library on Microsoft Windows: replace the WHATEVER 
+// part of the macro name with the name of the library that you want to 
+// dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or 
+// BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) 
+// modifiers, so that the compiler knows which symbols to look for in a dll 
+// rather than in a static library).  
+// Note that there may be some libraries that can only 
+// be linked in one way (statically or dynamically), 
+// in these cases this macro is unsupported.
+// #define BOOST_WHATEVER_DYN_LINK
+ 
+// BOOST_ALL_NO_LIB: Tells the config system not to automatically select 
+// which libraries to link against.  
+// Normally if a compiler supports #pragma lib, then the correct library 
+// build variant will be automatically selected and linked against, 
+// simply by the act of including one of that library's headers.  
+// This macro turns that feature off.
+// #define BOOST_ALL_NO_LIB
+ 
+// BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically 
+// select which library to link against for library "whatever", 
+// replace WHATEVER in the macro name with the name of the library; 
+// for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB.  
+// Normally if a compiler supports #pragma lib, then the correct library 
+// build variant will be automatically selected and linked against, simply 
+// by the act of including one of that library's headers.  This macro turns 
+// that feature off.
+// #define BOOST_WHATEVER_NO_LIB
+ 
+
+
diff --git a/libktorrent/miniboost/boost/config/warning_disable.hpp b/libktorrent/miniboost/boost/config/warning_disable.hpp
new file mode 100644
index 00000000..fea8e829
--- /dev/null
+++ b/libktorrent/miniboost/boost/config/warning_disable.hpp
@@ -0,0 +1,47 @@
+//  Copyright John Maddock 2008
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  This file exists to turn off some overly-pedantic warning emitted
+//  by certain compilers.  You should include this header only in:
+//
+//  * A test case, before any other headers, or,
+//  * A library source file before any other headers.
+//
+//  IT SHOULD NOT BE INCLUDED BY ANY BOOST HEADER.
+//
+//  YOU SHOULD NOT INCLUDE IT IF YOU CAN REASONABLY FIX THE WARNING.
+//
+//  The only warnings disabled here are those that are:
+//
+//  * Quite unreasonably pedantic.
+//  * Generally only emitted by a single compiler.
+//  * Can't easily be fixed: for example if the vendors own std lib 
+//    code emits these warnings!
+//
+//  Note that THIS HEADER MUST NOT INCLUDE ANY OTHER HEADERS:
+//  not even std library ones!  Doing so may turn the warning
+//  off too late to be of any use.  For example the VC++ C4996
+//  warning can be emitted from  if that header is included
+//  before or by this one :-(
+//
+
+#ifndef BOOST_CONFIG_WARNING_DISABLE_HPP
+#define BOOST_CONFIG_WARNING_DISABLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) 
+   // Error 'function': was declared deprecated
+   // http://msdn2.microsoft.com/en-us/library/ttcz0bys(VS.80).aspx
+   // This error is emitted when you use some perfectly conforming
+   // std lib functions in a perfectly correct way, and also by
+   // some of Microsoft's own std lib code !
+#  pragma warning(disable:4996)
+#endif
+#if defined(__INTEL_COMPILER) || defined(__ICL)
+   // As above: gives warning when a "deprecated"
+   // std library function is encountered.
+#  pragma warning(disable:1786)
+#endif
+
+#endif // BOOST_CONFIG_WARNING_DISABLE_HPP
diff --git a/libktorrent/miniboost/boost/container/allocator_traits.hpp b/libktorrent/miniboost/boost/container/allocator_traits.hpp
new file mode 100644
index 00000000..4857212c
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/allocator_traits.hpp
@@ -0,0 +1,406 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Pablo Halpern 2009. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP
+#define BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include  //numeric_limits<>::max()
+#include     //placement new
+#include  //std::allocator
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include 
+#endif
+
+namespace boost {
+namespace container {
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+namespace container_detail {
+
+//workaround needed for C++03 compilers with no construct()
+//supporting rvalue references
+template
+struct is_std_allocator
+{  static const bool value = false; };
+
+template
+struct is_std_allocator< std::allocator >
+{  static const bool value = true; };
+
+}  //namespace container_detail {
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! The class template allocator_traits supplies a uniform interface to all allocator types.
+//! This class is a C++03-compatible implementation of std::allocator_traits
+template 
+struct allocator_traits
+{
+   //allocator_type
+   typedef Alloc allocator_type;
+   //value_type
+   typedef typename Alloc::value_type         value_type;
+
+   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      //! Alloc::pointer if such a type exists; otherwise, value_type*
+      //!
+      typedef unspecified pointer;
+      //! Alloc::const_pointer if such a type exists ; otherwise, pointer_traits::rebind::rebind.
+      //!
+      typedef see_documentation void_pointer;
+      //! Alloc::const_void_pointer if such a type exists ; otherwis e, pointer_traits::rebind::difference_type.
+      //!
+      typedef see_documentation difference_type;
+      //! Alloc::size_type if such a type exists ; otherwise, make_unsigned::type
+      //!
+      typedef see_documentation size_type;
+      //! Alloc::propagate_on_container_copy_assignment if such a type exists, otherwise an integral_constant
+      //! type with internal constant static member value == false.
+      typedef see_documentation propagate_on_container_copy_assignment;
+      //! Alloc::propagate_on_container_move_assignment if such a type exists, otherwise an integral_constant
+      //! type with internal constant static member value == false.
+      typedef see_documentation propagate_on_container_move_assignment;
+      //! Alloc::propagate_on_container_swap if such a type exists, otherwise an integral_constant
+      //! type with internal constant static member value == false.
+      typedef see_documentation propagate_on_container_swap;
+      //! Defines an allocator: Alloc::rebind::other if such a type exists; otherwise, Alloc
+      //! if Alloc is a class template instantiation of the form Alloc, where Args is zero or
+      //! more type arguments ; otherwise, the instantiation of rebind_alloc is ill-formed.
+      //!
+      //! In C++03 compilers rebind_alloc is a struct derived from an allocator
+      //! deduced by previously detailed rules.
+      template  using rebind_alloc = see_documentation;
+
+      //! In C++03 compilers rebind_traits is a struct derived from
+      //! allocator_traits, where OtherAlloc is
+      //! the allocator deduced by rules explained in rebind_alloc.
+      template  using rebind_traits = allocator_traits >;
+
+      //! Non-standard extension: Portable allocator rebind for C++03 and C++11 compilers.
+      //! type is an allocator related to Alloc deduced deduced by rules explained in rebind_alloc.
+      template 
+      struct portable_rebind_alloc
+      {  typedef see_documentation type;  };
+   #else
+      //pointer
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         pointer, value_type*)
+            pointer;
+      //const_pointer
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
+         const_pointer, typename boost::intrusive::pointer_traits::template
+            rebind_pointer)
+               const_pointer;
+      //reference
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         reference, typename container_detail::unvoid::type&)
+            reference;
+      //const_reference
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         const_reference, const typename container_detail::unvoid::type&)
+               const_reference;
+      //void_pointer
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
+         void_pointer, typename boost::intrusive::pointer_traits::template
+            rebind_pointer)
+               void_pointer;
+      //const_void_pointer
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
+         const_void_pointer, typename boost::intrusive::pointer_traits::template
+            rebind_pointer)
+               const_void_pointer;
+      //difference_type
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         difference_type, std::ptrdiff_t)
+            difference_type;
+      //size_type
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         size_type, std::size_t)
+            size_type;
+      //propagate_on_container_copy_assignment
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         propagate_on_container_copy_assignment, boost::false_type)
+            propagate_on_container_copy_assignment;
+      //propagate_on_container_move_assignment
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         propagate_on_container_move_assignment, boost::false_type)
+            propagate_on_container_move_assignment;
+      //propagate_on_container_swap
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
+         propagate_on_container_swap, boost::false_type)
+            propagate_on_container_swap;
+
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+         //C++11
+         template  using rebind_alloc  = typename boost::intrusive::detail::type_rebinder::type;
+         template  using rebind_traits = allocator_traits< rebind_alloc >;
+      #else    // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+         //Some workaround for C++03 or C++11 compilers with no template aliases
+         template 
+         struct rebind_alloc : boost::intrusive::detail::type_rebinder::type
+         {
+            typedef typename boost::intrusive::detail::type_rebinder::type Base;
+            #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+            template 
+            rebind_alloc(BOOST_FWD_REF(Args)... args)
+               : Base(boost::forward(args)...)
+            {}
+            #else    // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+            #define BOOST_PP_LOCAL_MACRO(n)                                                        \
+            BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \
+            rebind_alloc(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                       \
+               : Base(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))                       \
+            {}                                                                                     \
+            //
+            #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+            #include BOOST_PP_LOCAL_ITERATE()
+            #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+         };
+
+         template 
+         struct rebind_traits
+            : allocator_traits::type>
+         {};
+      #endif   // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      template 
+      struct portable_rebind_alloc
+      {  typedef typename boost::intrusive::detail::type_rebinder::type type;  };
+   #endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
+
+   //! Returns: a.allocate(n)
+   //!
+   static pointer allocate(Alloc &a, size_type n)
+   {  return a.allocate(n);  }
+
+   //! Returns: a.deallocate(p, n)
+   //!
+   //! Throws: Nothing
+   static void deallocate(Alloc &a, pointer p, size_type n)
+   {  a.deallocate(p, n);  }
+
+   //! Effects: calls a.allocate(n, p) if that call is well-formed;
+   //! otherwise, invokes a.allocate(n)
+   static pointer allocate(Alloc &a, size_type n, const_void_pointer p)
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_allocate
+            ::value;
+      ::boost::integral_constant flag;
+      return allocator_traits::priv_allocate(flag, a, n, p);
+   }
+
+   //! Effects: calls a.destroy(p) if that call is well-formed;
+   //! otherwise, invokes p->~T().
+   template
+   static void destroy(Alloc &a, T*p) BOOST_CONTAINER_NOEXCEPT
+   {
+      typedef T* destroy_pointer;
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_destroy
+            ::value;
+      ::boost::integral_constant flag;
+      allocator_traits::priv_destroy(flag, a, p);
+   }
+
+   //! Returns: a.max_size() if that expression is well-formed; otherwise,
+   //! numeric_limits::max().
+   static size_type max_size(const Alloc &a) BOOST_CONTAINER_NOEXCEPT
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_max_size
+            ::value;
+      ::boost::integral_constant flag;
+      return allocator_traits::priv_max_size(flag, a);
+   }
+
+   //! Returns: a.select_on_container_copy_construction() if that expression is well-formed;
+   //! otherwise, a.
+   static
+   #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   typename container_detail::if_c
+      <  boost::container::container_detail::
+                  has_member_function_callable_with_select_on_container_copy_construction
+                     ::value
+      , Alloc
+      , const Alloc &
+      >::type
+   #else
+   Alloc
+   #endif
+   select_on_container_copy_construction(const Alloc &a)
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_select_on_container_copy_construction
+            ::value;
+      ::boost::integral_constant flag;
+      return allocator_traits::priv_select_on_container_copy_construction(flag, a);
+   }
+
+   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      //! Effects: calls a.construct(p, std::forward(args)...) if that call is well-formed;
+      //! otherwise, invokes ::new (static_cast(p)) T(std::forward(args)...)
+      template 
+      static void construct(Alloc & a, T* p, BOOST_FWD_REF(Args)... args)
+      {
+         ::boost::integral_constant::value> flag;
+         allocator_traits::priv_construct(flag, a, p, ::boost::forward(args)...);
+      }
+   #endif
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+   #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      private:
+      static pointer priv_allocate(boost::true_type, Alloc &a, size_type n, const_void_pointer p)
+      {  return a.allocate(n, p);  }
+
+      static pointer priv_allocate(boost::false_type, Alloc &a, size_type n, const_void_pointer)
+      {  return allocator_traits::allocate(a, n);  }
+
+      template
+      static void priv_destroy(boost::true_type, Alloc &a, T* p) BOOST_CONTAINER_NOEXCEPT
+      {  a.destroy(p);  }
+
+      template
+      static void priv_destroy(boost::false_type, Alloc &, T* p) BOOST_CONTAINER_NOEXCEPT
+      {  p->~T(); (void)p;  }
+
+      static size_type priv_max_size(boost::true_type, const Alloc &a) BOOST_CONTAINER_NOEXCEPT
+      {  return a.max_size();  }
+
+      static size_type priv_max_size(boost::false_type, const Alloc &) BOOST_CONTAINER_NOEXCEPT
+      {  return (std::numeric_limits::max)();  }
+
+      static Alloc priv_select_on_container_copy_construction(boost::true_type, const Alloc &a)
+      {  return a.select_on_container_copy_construction();  }
+
+      static const Alloc &priv_select_on_container_copy_construction(boost::false_type, const Alloc &a) BOOST_CONTAINER_NOEXCEPT
+      {  return a;  }
+
+      #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+         template
+         static void priv_construct(boost::false_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)
+         {
+            const bool value = boost::container::container_detail::
+                  has_member_function_callable_with_construct
+                     < Alloc, T*, Args... >::value;
+            ::boost::integral_constant flag;
+            priv_construct_dispatch2(flag, a, p, ::boost::forward(args)...);
+         }
+
+         template
+         static void priv_construct(boost::true_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)
+         {
+            priv_construct_dispatch2(boost::false_type(), a, p, ::boost::forward(args)...);
+         }
+
+         template
+         static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)
+         {  a.construct( p, ::boost::forward(args)...);  }
+
+         template
+         static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p, BOOST_FWD_REF(Args) ...args)
+         {  ::new((void*)p) T(::boost::forward(args)...); }
+      #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+         public:
+         #define BOOST_PP_LOCAL_MACRO(n)                                                              \
+         template                                 \
+         static void construct(Alloc &a, T *p                                                         \
+                              BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))            \
+         {                                                                                            \
+            ::boost::integral_constant::value> flag;  \
+            allocator_traits::priv_construct(flag, a, p                                               \
+               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));                       \
+         }                                                                                            \
+         //
+         #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+         #include BOOST_PP_LOCAL_ITERATE()
+
+         private:
+         #define BOOST_PP_LOCAL_MACRO(n)                                                                    \
+         template                                      \
+         static void priv_construct(boost::false_type, Alloc &a, T *p                                       \
+                        BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST,_))                         \
+         {                                                                                                  \
+            const bool value =                                                                              \
+               boost::container::container_detail::has_member_function_callable_with_construct              \
+                     < Alloc, T* BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_FWD_TYPE, _) >::value;        \
+            ::boost::integral_constant flag;                                                   \
+            priv_construct_dispatch2(flag, a, p                                                             \
+               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                            \
+         }                                                                                                  \
+                                                                                                            \
+         template                                      \
+         static void priv_construct(boost::true_type, Alloc &a, T *p                                        \
+                        BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST,_))                         \
+         {                                                                                                  \
+            priv_construct_dispatch2(boost::false_type(), a, p                                              \
+               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                            \
+         }                                                                                                  \
+                                                                                                            \
+         template                                      \
+         static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p                              \
+                        BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST,_))                         \
+         {  a.construct( p BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );  }             \
+                                                                                                            \
+         template                                      \
+         static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p                              \
+                        BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _) )                       \
+         {  ::new((void*)p) T(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }                     \
+         //
+         #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
+         #include BOOST_PP_LOCAL_ITERATE()
+      #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+      template
+      static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p, ::boost::container::default_init_t)
+      {  ::new((void*)p) T; }
+   #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+   #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+};
+
+}  //namespace container {
+}  //namespace boost {
+
+#include 
+
+#endif // ! defined(BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP)
diff --git a/libktorrent/miniboost/boost/container/container_fwd.hpp b/libktorrent/miniboost/boost/container/container_fwd.hpp
new file mode 100644
index 00000000..415de0f3
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/container_fwd.hpp
@@ -0,0 +1,275 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP
+#define BOOST_CONTAINER_CONTAINER_FWD_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+//! \file
+//! This header file forward declares the following containers:
+//!   - boost::container::vector
+//!   - boost::container::stable_vector
+//!   - boost::container::static_vector
+//!   - boost::container::slist
+//!   - boost::container::list
+//!   - boost::container::set
+//!   - boost::container::multiset
+//!   - boost::container::map
+//!   - boost::container::multimap
+//!   - boost::container::flat_set
+//!   - boost::container::flat_multiset
+//!   - boost::container::flat_map
+//!   - boost::container::flat_multimap
+//!   - boost::container::basic_string
+//!   - boost::container::string
+//!   - boost::container::wstring
+//!
+//! It forward declares the following allocators:
+//!   - boost::container::allocator
+//!   - boost::container::node_allocator
+//!   - boost::container::adaptive_pool
+//!
+//! And finally it defines the following types
+
+//////////////////////////////////////////////////////////////////////////////
+//                        Standard predeclarations
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+namespace boost{
+namespace intrusive{
+   //Create namespace to avoid compilation errors
+}}
+
+namespace boost{ namespace container{ namespace container_detail{
+
+namespace bi = boost::intrusive;
+
+}}}
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//////////////////////////////////////////////////////////////////////////////
+//                             Containers
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost {
+namespace container {
+
+//! Enumeration used to configure ordered associative containers
+//! with a concrete tree implementation.
+enum tree_type_enum
+{
+   red_black_tree,
+   avl_tree,
+   scapegoat_tree,
+   splay_tree
+};
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+template  >
+class vector;
+
+template  >
+class stable_vector;
+
+template 
+class static_vector;
+
+template  >
+class deque;
+
+template  >
+class list;
+
+template  >
+class slist;
+
+template
+struct tree_opt;
+
+typedef tree_opt tree_assoc_defaults;
+
+template 
+         ,class Allocator = std::allocator
+         ,class Options = tree_assoc_defaults >
+class set;
+
+template 
+         ,class Allocator = std::allocator
+         ,class Options = tree_assoc_defaults >
+class multiset;
+
+template 
+         ,class Allocator = std::allocator >
+         ,class Options = tree_assoc_defaults >
+class map;
+
+template 
+         ,class Allocator = std::allocator >
+         ,class Options = tree_assoc_defaults >
+class multimap;
+
+template 
+         ,class Allocator = std::allocator >
+class flat_set;
+
+template 
+         ,class Allocator = std::allocator >
+class flat_multiset;
+
+template 
+         ,class Allocator = std::allocator > >
+class flat_map;
+
+template 
+         ,class Allocator = std::allocator > >
+class flat_multimap;
+
+template 
+         ,class Allocator  = std::allocator >
+class basic_string;
+
+typedef basic_string
+   
+   ,std::allocator >
+string;
+
+typedef basic_string
+   
+   ,std::allocator >
+wstring;
+
+static const std::size_t ADP_nodes_per_block    = 256u;
+static const std::size_t ADP_max_free_blocks    = 2u;
+static const std::size_t ADP_overhead_percent   = 1u;
+static const std::size_t ADP_only_alignment     = 0u;
+
+template < class T
+         , std::size_t NodesPerBlock   = ADP_nodes_per_block
+         , std::size_t MaxFreeBlocks   = ADP_max_free_blocks
+         , std::size_t OverheadPercent = ADP_overhead_percent
+         , unsigned Version = 2
+         >
+class adaptive_pool;
+
+template < class T
+         , unsigned Version = 2
+         , unsigned int AllocationDisableMask = 0>
+class allocator;
+
+static const std::size_t NodeAlloc_nodes_per_block = 256u;
+
+template
+   < class T
+   , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block
+   , std::size_t Version = 2>
+class node_allocator;
+
+#else
+
+//! Default options for tree-based associative containers
+//!   - tree_type
+//!   - optimize_size
+typedef implementation_defined tree_assoc_defaults;
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! Type used to tag that the input range is
+//! guaranteed to be ordered
+struct ordered_range_t
+{};
+
+//! Value used to tag that the input range is
+//! guaranteed to be ordered
+static const ordered_range_t ordered_range = ordered_range_t();
+
+//! Type used to tag that the input range is
+//! guaranteed to be ordered and unique
+struct ordered_unique_range_t
+   : public ordered_range_t
+{};
+
+//! Value used to tag that the input range is
+//! guaranteed to be ordered and unique
+static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
+
+//! Type used to tag that the inserted values
+//! should be default initialized
+struct default_init_t
+{};
+
+//! Value used to tag that the inserted values
+//! should be default initialized
+static const default_init_t default_init = default_init_t();
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! Type used to tag that the inserted values
+//! should be value initialized
+struct value_init_t
+{};
+
+//! Value used to tag that the inserted values
+//! should be value initialized
+static const value_init_t value_init = value_init_t();
+
+namespace container_detail_really_deep_namespace {
+
+//Otherwise, gcc issues a warning of previously defined
+//anonymous_instance and unique_instance
+struct dummy
+{
+   dummy()
+   {
+      (void)ordered_range;
+      (void)ordered_unique_range;
+      (void)default_init;
+   }
+};
+
+}  //detail_really_deep_namespace {
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+}}  //namespace boost { namespace container {
+
+#endif //#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP
diff --git a/libktorrent/miniboost/boost/container/detail/config_begin.hpp b/libktorrent/miniboost/boost/container/detail/config_begin.hpp
new file mode 100644
index 00000000..6c54befc
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/detail/config_begin.hpp
@@ -0,0 +1,54 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED
+#define BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED
+#include 
+
+#endif   //BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED
+
+#ifdef BOOST_MSVC
+   #ifndef _CRT_SECURE_NO_DEPRECATE
+   #define  BOOST_CONTAINER_DETAIL_CRT_SECURE_NO_DEPRECATE
+   #define _CRT_SECURE_NO_DEPRECATE
+   #endif
+   #ifndef _SCL_SECURE_NO_WARNINGS
+   #define  BOOST_CONTAINER_DETAIL_SCL_SECURE_NO_WARNINGS
+   #define _SCL_SECURE_NO_WARNINGS
+   #endif
+   #pragma warning (push)
+   #pragma warning (disable : 4702) // unreachable code
+   #pragma warning (disable : 4706) // assignment within conditional expression
+   #pragma warning (disable : 4127) // conditional expression is constant
+   #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
+   #pragma warning (disable : 4284) // odd return type for operator->
+   #pragma warning (disable : 4244) // possible loss of data
+   #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
+   #pragma warning (disable : 4267) // conversion from "X" to "Y", possible loss of data
+   #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
+   #pragma warning (disable : 4355) // "this" : used in base member initializer list
+   #pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated
+   #pragma warning (disable : 4511) // copy constructor could not be generated
+   #pragma warning (disable : 4512) // assignment operator could not be generated
+   #pragma warning (disable : 4514) // unreferenced inline removed
+   #pragma warning (disable : 4521) // Disable "multiple copy constructors specified"
+   #pragma warning (disable : 4522) // "class" : multiple assignment operators specified
+   #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
+   #pragma warning (disable : 4710) // function not inlined
+   #pragma warning (disable : 4711) // function selected for automatic inline expansion
+   #pragma warning (disable : 4786) // identifier truncated in debug info
+   #pragma warning (disable : 4996) // "function": was declared deprecated
+   #pragma warning (disable : 4197) // top-level volatile in cast is ignored
+   #pragma warning (disable : 4541) // 'typeid' used on polymorphic type 'boost::exception'
+                                    //    with /GR-; unpredictable behavior may result
+   #pragma warning (disable : 4673) //  throwing '' the following types will not be considered at the catch site
+   #pragma warning (disable : 4671) //  the copy constructor is inaccessible
+   #pragma warning (disable : 4584) //  X is already a base-class of Y
+   #pragma warning (disable : 4510) //  default constructor could not be generated
+#endif   //BOOST_MSVC
diff --git a/libktorrent/miniboost/boost/container/detail/config_end.hpp b/libktorrent/miniboost/boost/container/detail/config_end.hpp
new file mode 100644
index 00000000..7217019b
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/detail/config_end.hpp
@@ -0,0 +1,21 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#if defined BOOST_MSVC
+   #pragma warning (pop)
+   #ifdef BOOST_CONTAINER_DETAIL_CRT_SECURE_NO_DEPRECATE
+   #undef BOOST_CONTAINER_DETAIL_CRT_SECURE_NO_DEPRECATE
+   #undef _CRT_SECURE_NO_DEPRECATE
+   #endif
+   #ifdef BOOST_CONTAINER_DETAIL_SCL_SECURE_NO_WARNINGS
+   #undef BOOST_CONTAINER_DETAIL_SCL_SECURE_NO_WARNINGS
+   #undef _SCL_SECURE_NO_WARNINGS
+   #endif
+#endif
+
diff --git a/libktorrent/miniboost/boost/container/detail/memory_util.hpp b/libktorrent/miniboost/boost/container/detail/memory_util.hpp
new file mode 100644
index 00000000..572d30ac
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/detail/memory_util.hpp
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_ALLOCATOR_MEMORY_UTIL_HPP
+#define BOOST_CONTAINER_ALLOCATOR_MEMORY_UTIL_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+#include 
+#include 
+
+#include 
+#include 
+#include 
+
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME allocate
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (2, 2, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME destroy
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 1, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME max_size
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME select_on_container_copy_construction
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME construct
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS+1, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME swap
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 1, ))
+#include BOOST_PP_ITERATE()
+
+namespace boost {
+namespace container {
+namespace container_detail {
+
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(pointer)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(const_pointer)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(const_reference)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(void_pointer)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(const_void_pointer)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(size_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(propagate_on_container_swap)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_compare)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(wrapped_value_compare)
+
+}  //namespace container_detail {
+}  //namespace container {
+}  //namespace boost {
+
+#include 
+
+#endif // ! defined(BOOST_CONTAINER_ALLOCATOR_MEMORY_UTIL_HPP)
diff --git a/libktorrent/miniboost/boost/container/detail/mpl.hpp b/libktorrent/miniboost/boost/container/detail/mpl.hpp
new file mode 100644
index 00000000..fc1a8a6d
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/detail/mpl.hpp
@@ -0,0 +1,183 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_MPL_HPP
+#define BOOST_CONTAINER_CONTAINER_DETAIL_MPL_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+#include 
+#include 
+
+#include 
+
+namespace boost {
+namespace container {
+namespace container_detail {
+
+template 
+struct integral_constant
+{
+   static const T value = val;
+   typedef integral_constant type;
+};
+
+template< bool C_ >
+struct bool_ : integral_constant
+{
+   static const bool value = C_;
+   operator bool() const { return bool_::value; }
+};
+
+typedef bool_        true_;
+typedef bool_       false_;
+
+typedef true_  true_type;
+typedef false_ false_type;
+
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+
+template 
+struct enable_if_c {
+  typedef T type;
+};
+
+template 
+struct enable_if_c {};
+
+template 
+struct enable_if : public enable_if_c {};
+
+template 
+struct disable_if : public enable_if_c {};
+
+template 
+struct disable_if_c : public enable_if_c {};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+
+template 
+struct is_convertible
+{
+   static const bool value = __is_convertible_to(T, U);
+};
+
+#else
+
+template 
+class is_convertible
+{
+   typedef char true_t;
+   class false_t { char dummy[2]; };
+   //use any_conversion as first parameter since in MSVC
+   //overaligned types can't go through ellipsis
+   static false_t dispatch(...);
+   static true_t  dispatch(U);
+   static T &trigger();
+   public:
+   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
+};
+
+#endif
+
+template<
+      bool C
+    , typename T1
+    , typename T2
+    >
+struct if_c
+{
+    typedef T1 type;
+};
+
+template<
+      typename T1
+    , typename T2
+    >
+struct if_c
+{
+    typedef T2 type;
+};
+
+template<
+      typename T1
+    , typename T2
+    , typename T3
+    >
+struct if_
+{
+   typedef typename if_c<0 != T1::value, T2, T3>::type type;
+};
+
+
+template 
+struct select1st
+{
+	typedef Pair                        argument_type;
+	typedef typename Pair::first_type   result_type;
+
+   template
+   const typename Pair::first_type& operator()(const OtherPair& x) const
+   {  return x.first;   }
+
+   const typename Pair::first_type& operator()(const typename Pair::first_type& x) const
+   {  return x;   }
+};
+
+// identity is an extension: it is not part of the standard.
+template 
+struct identity
+{
+	typedef T   argument_type;
+	typedef T   result_type;
+
+   typedef T type;
+   const T& operator()(const T& x) const
+   { return x; }
+};
+
+template
+struct ls_zeros
+{
+   static const std::size_t value = (S & std::size_t(1)) ? 0 : (1u + ls_zeros<(S >> 1u)>::value);
+};
+
+template<>
+struct ls_zeros<0>
+{
+   static const std::size_t value = 0;
+};
+
+template<>
+struct ls_zeros<1>
+{
+   static const std::size_t value = 0;
+};
+
+template  struct unvoid { typedef T type; };
+template <> struct unvoid { struct type { }; };
+template <> struct unvoid { struct type { }; };
+
+}  //namespace container_detail {
+}  //namespace container {
+}  //namespace boost {
+
+#include 
+
+#endif   //#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_MPL_HPP
+
diff --git a/libktorrent/miniboost/boost/container/detail/preprocessor.hpp b/libktorrent/miniboost/boost/container/detail/preprocessor.hpp
new file mode 100644
index 00000000..7e4f5eb0
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/detail/preprocessor.hpp
@@ -0,0 +1,232 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
+#define BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+#include 
+#include 
+#include 
+
+#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+//#error "This file is not needed when perfect forwarding is available"
+#endif   //BOOST_CONTAINER_PERFECT_FORWARDING
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#define BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS 10
+
+//Note:
+//We define template parameters as const references to
+//be able to bind temporaries. After that we will un-const them.
+//This cast is ugly but it is necessary until "perfect forwarding"
+//is achieved in C++0x. Meanwhile, if we want to be able to
+//bind rvalues with non-const references, we have to be ugly
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+   #define BOOST_CONTAINER_PP_PARAM_LIST(z, n, data) \
+   BOOST_PP_CAT(P, n) && BOOST_PP_CAT(p, n) \
+   //!
+#else
+   #define BOOST_CONTAINER_PP_PARAM_LIST(z, n, data) \
+   const BOOST_PP_CAT(P, n) & BOOST_PP_CAT(p, n) \
+   //!
+#endif   //#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#define BOOST_CONTAINER_PP_CONST_REF_PARAM_LIST_Q(z, n, Data) \
+const BOOST_PP_CAT(Q, n) & BOOST_PP_CAT(q, n) \
+//!
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+   #define BOOST_CONTAINER_PP_PARAM(U, u) \
+   U && u \
+   //!
+#else
+   #define BOOST_CONTAINER_PP_PARAM(U, u) \
+   const U & u \
+   //!
+#endif   //#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+   #define BOOST_CONTAINER_PP_PARAM_INIT(z, n, data) \
+   BOOST_PP_CAT(m_p, n) (::boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ))           \
+   //!
+
+#else //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+   #define BOOST_CONTAINER_PP_PARAM_INIT(z, n, data) \
+   BOOST_PP_CAT(m_p, n) (const_cast(BOOST_PP_CAT(p, n))) \
+   //!
+#endif   //#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+   #if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+      namespace boost {
+      namespace container {
+      namespace container_detail {
+         template
+         struct ref_holder;
+
+         template
+         struct ref_holder
+         {
+            explicit ref_holder(T &t)
+               : t_(t)
+            {}
+            T &t_;
+            T & get() {  return t_;   }
+         };
+
+         template
+         struct ref_holder
+         {
+            explicit ref_holder(const T &t)
+               : t_(t)
+            {}
+            const T &t_;
+            const T & get() {  return t_;   }
+         };
+
+         template
+         struct ref_holder
+         {
+            explicit ref_holder(const T &t)
+               : t_(t)
+            {}
+            const T &t_;
+            const T & get() {  return t_;   }
+         };
+
+         template
+         struct ref_holder
+         {
+            explicit ref_holder(T &&t)
+               : t_(t)
+            {}
+            T &t_;
+            T && get() {  return ::boost::move(t_);   }
+         };
+
+         template
+         struct ref_holder
+         {
+            explicit ref_holder(T &&t)
+               : t_(t)
+            {}
+            T &t_;
+            T && get()  { return ::boost::move(t_); }
+         };
+
+      }  //namespace container_detail {
+      }  //namespace container {
+      }  //namespace boost {
+
+      #define BOOST_CONTAINER_PP_PARAM_DEFINE(z, n, data)  \
+         ::boost::container::container_detail::ref_holder BOOST_PP_CAT(m_p, n);  \
+      //!
+
+   #else //BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
+
+      #define BOOST_CONTAINER_PP_PARAM_DEFINE(z, n, data)  \
+      BOOST_PP_CAT(P, n) && BOOST_PP_CAT(m_p, n);            \
+      //!
+
+   #endif //defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+#else //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+   #define BOOST_CONTAINER_PP_PARAM_DEFINE(z, n, data)  \
+   BOOST_PP_CAT(P, n) & BOOST_PP_CAT(m_p, n);             \
+   //!
+#endif   //#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+   #define BOOST_CONTAINER_PP_MEMBER_FORWARD(z, n, data) BOOST_PP_CAT(this->m_p, n).get() \
+   //!
+
+#else //!defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+   #define BOOST_CONTAINER_PP_MEMBER_FORWARD(z, n, data) \
+   ::boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(this->m_p, n) ) \
+   //!
+
+#endif   //!defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+#define BOOST_CONTAINER_PP_PARAM_INC(z, n, data)   \
+  BOOST_PP_CAT(++this->m_p, n)                     \
+//!
+
+#define BOOST_CONTAINER_PP_IDENTITY(z, n, data) data
+
+
+#define BOOST_CONTAINER_PP_PARAM_FORWARD(z, n, data) \
+::boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ) \
+//!
+
+#define BOOST_CONTAINER_PP_DECLVAL(z, n, data) \
+::boost::move_detail::declval< BOOST_PP_CAT(P, n) >() \
+//!
+
+#define BOOST_CONTAINER_PP_MEMBER_IT_FORWARD(z, n, data) \
+BOOST_PP_CAT(*this->m_p, n) \
+//!
+
+#define BOOST_CONTAINER_PP_TEMPLATE_PARAM_VOID_DEFAULT(z, n, data)   \
+  BOOST_PP_CAT(class P, n) = void                                    \
+//!
+
+#define BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT(z, n, default_type) \
+  BOOST_PP_CAT(class P, n) = default_type                                  \
+//!
+
+#define BOOST_CONTAINER_PP_STATIC_PARAM_REF_DECLARE(z, n, data) \
+   static BOOST_PP_CAT(P, n) & BOOST_PP_CAT(p, n); \
+//!
+
+#define BOOST_CONTAINER_PP_PARAM_PASS(z, n, data) \
+   BOOST_PP_CAT(p, n) \
+//!
+
+#define BOOST_CONTAINER_PP_FWD_TYPE(z, n, data) \
+   typename ::boost::move_detail::forward_type< BOOST_PP_CAT(P, n) >::type \
+//!
+
+#include 
+
+//#else
+
+//#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
+//#error "This file is not needed when perfect forwarding is available"
+//#endif   //BOOST_CONTAINER_PERFECT_FORWARDING
+
+#endif //#ifndef BOOST_CONTAINER_DETAIL_PREPROCESSOR_HPP
diff --git a/libktorrent/miniboost/boost/container/detail/workaround.hpp b/libktorrent/miniboost/boost/container/detail/workaround.hpp
new file mode 100644
index 00000000..c2908612
--- /dev/null
+++ b/libktorrent/miniboost/boost/container/detail/workaround.hpp
@@ -0,0 +1,63 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+#define BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
+
+#include 
+
+#if    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)\
+    && !defined(BOOST_INTERPROCESS_DISABLE_VARIADIC_TMPL)
+   #define BOOST_CONTAINER_PERFECT_FORWARDING
+#endif
+
+#if defined(BOOST_NO_CXX11_NOEXCEPT)
+   #if defined(BOOST_MSVC)
+      #define BOOST_CONTAINER_NOEXCEPT throw()
+   #else
+      #define BOOST_CONTAINER_NOEXCEPT
+   #endif
+   #define BOOST_CONTAINER_NOEXCEPT_IF(x)
+#else
+   #define BOOST_CONTAINER_NOEXCEPT    noexcept
+   #define BOOST_CONTAINER_NOEXCEPT_IF(x) noexcept(x)
+#endif
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && defined(__GXX_EXPERIMENTAL_CXX0X__)\
+    && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40700)
+   #define BOOST_CONTAINER_UNIMPLEMENTED_PACK_EXPANSION_TO_FIXED_LIST
+#endif
+
+#if !defined(BOOST_FALLTHOUGH)
+   #define BOOST_CONTAINER_FALLTHOUGH
+#else
+   #define BOOST_CONTAINER_FALLTHOUGH BOOST_FALLTHOUGH;
+#endif
+
+//Macros for documentation purposes. For code, expands to the argument
+#define BOOST_CONTAINER_IMPDEF(TYPE) TYPE
+#define BOOST_CONTAINER_SEEDOC(TYPE) TYPE
+
+//Macros for memset optimization. In most platforms
+//memsetting pointers and floatings is safe and faster.
+//
+//If your platform does not offer these guarantees
+//define these to value zero.
+#ifndef BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_NOT_ZERO
+#define BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO 1
+#endif
+
+#ifndef BOOST_CONTAINER_MEMZEROED_POINTER_IS_NOT_NULL
+#define BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL
+#endif
+
+#include 
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
diff --git a/libktorrent/miniboost/boost/core/addressof.hpp b/libktorrent/miniboost/boost/core/addressof.hpp
new file mode 100644
index 00000000..a90fcc3e
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/addressof.hpp
@@ -0,0 +1,162 @@
+// Copyright (C) 2002 Brad King (brad.king@kitware.com)
+//                    Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Copyright (C) 2002, 2008, 2013 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_CORE_ADDRESSOF_HPP
+#define BOOST_CORE_ADDRESSOF_HPP
+
+# include 
+# include 
+# include 
+
+namespace boost
+{
+
+namespace detail
+{
+
+template struct addr_impl_ref
+{
+    T & v_;
+
+    BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
+    BOOST_FORCEINLINE operator T& () const { return v_; }
+
+private:
+    addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template struct addressof_impl
+{
+    static BOOST_FORCEINLINE T * f( T & v, long )
+    {
+        return reinterpret_cast(
+            &const_cast(reinterpret_cast(v)));
+    }
+
+    static BOOST_FORCEINLINE T * f( T * v, int )
+    {
+        return v;
+    }
+};
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+#if defined( __clang__ ) && !defined( _LIBCPP_VERSION ) && !defined( BOOST_NO_CXX11_DECLTYPE )
+
+    typedef decltype(nullptr) addr_nullptr_t;
+
+#else
+
+    typedef std::nullptr_t addr_nullptr_t;
+
+#endif
+
+template<> struct addressof_impl< addr_nullptr_t >
+{
+    typedef addr_nullptr_t T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+template<> struct addressof_impl< addr_nullptr_t const >
+{
+    typedef addr_nullptr_t const T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+template<> struct addressof_impl< addr_nullptr_t volatile >
+{
+    typedef addr_nullptr_t volatile T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+template<> struct addressof_impl< addr_nullptr_t const volatile >
+{
+    typedef addr_nullptr_t const volatile T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+#endif
+
+} // namespace detail
+
+template
+BOOST_FORCEINLINE
+T * addressof( T & v )
+{
+#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC )
+
+    return boost::detail::addressof_impl::f( v, 0 );
+
+#else
+
+    return boost::detail::addressof_impl::f( boost::detail::addr_impl_ref( v ), 0 );
+
+#endif
+}
+
+#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
+
+namespace detail
+{
+
+template struct addressof_addp
+{
+    typedef T * type;
+};
+
+} // namespace detail
+
+template< class T, std::size_t N >
+BOOST_FORCEINLINE
+typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
+{
+    return &t;
+}
+
+#endif
+
+// Borland doesn't like casting an array reference to a char reference
+// but these overloads work around the problem.
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template
+BOOST_FORCEINLINE
+T (*addressof(T (&t)[N]))[N]
+{
+   return reinterpret_cast(&t);
+}
+
+template
+BOOST_FORCEINLINE
+const T (*addressof(const T (&t)[N]))[N]
+{
+   return reinterpret_cast(&t);
+}
+#endif
+
+} // namespace boost
+
+#endif // BOOST_CORE_ADDRESSOF_HPP
diff --git a/libktorrent/miniboost/boost/core/checked_delete.hpp b/libktorrent/miniboost/boost/core/checked_delete.hpp
new file mode 100644
index 00000000..b086e03e
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/checked_delete.hpp
@@ -0,0 +1,69 @@
+#ifndef BOOST_CORE_CHECKED_DELETE_HPP
+#define BOOST_CORE_CHECKED_DELETE_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/checked_delete.hpp
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) 2003 Daniel Frey
+//  Copyright (c) 2003 Howard Hinnant
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See http://www.boost.org/libs/core/doc/html/core/checked_delete.html for documentation.
+//
+
+namespace boost
+{
+
+// verify that types are complete for increased safety
+
+template inline void checked_delete(T * x)
+{
+    // intentionally complex - simplification causes regressions
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template 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 struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        // boost:: disables ADL
+        boost::checked_delete(x);
+    }
+};
+
+template struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_CHECKED_DELETE_HPP
diff --git a/libktorrent/miniboost/boost/core/demangle.hpp b/libktorrent/miniboost/boost/core/demangle.hpp
new file mode 100644
index 00000000..eebd0ce0
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/demangle.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
+#define BOOST_CORE_DEMANGLE_HPP_INCLUDED
+
+// core::demangle
+//
+// Copyright 2014 Peter Dimov
+// Copyright 2014 Andrey Semashev
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include 
+#include 
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#if defined( __clang__ ) && defined( __has_include )
+# if __has_include()
+#  define BOOST_CORE_HAS_CXXABI_H
+# endif
+#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )
+# define BOOST_CORE_HAS_CXXABI_H
+#endif
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+# include 
+# include 
+# include 
+#endif
+
+namespace boost
+{
+
+namespace core
+{
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT;
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT;
+
+class scoped_demangled_name
+{
+private:
+    char const * m_p;
+
+public:
+    explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT :
+        m_p( demangle_alloc( name ) )
+    {
+    }
+
+    ~scoped_demangled_name() BOOST_NOEXCEPT
+    {
+        demangle_free( m_p );
+    }
+
+    char const * get() const BOOST_NOEXCEPT
+    {
+        return m_p;
+    }
+
+    BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& ))
+    BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& ))
+};
+
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+    int status = 0;
+    std::size_t size = 0;
+    return abi::__cxa_demangle( name, NULL, &size, &status );
+}
+
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT
+{
+    std::free( const_cast< char* >( name ) );
+}
+
+inline std::string demangle( char const * name )
+{
+    scoped_demangled_name demangled_name( name );
+    char const * const p = demangled_name.get();
+    if( p )
+    {
+        return p;
+    }
+    else
+    {
+        return name;
+    }
+}
+
+#else
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+    return name;
+}
+
+inline void demangle_free( char const * ) BOOST_NOEXCEPT
+{
+}
+
+inline std::string demangle( char const * name )
+{
+    return name;
+}
+
+#endif
+
+} // namespace core
+
+} // namespace boost
+
+#undef BOOST_CORE_HAS_CXXABI_H
+
+#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
diff --git a/libktorrent/miniboost/boost/core/enable_if.hpp b/libktorrent/miniboost/boost/core/enable_if.hpp
new file mode 100644
index 00000000..a3302b18
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/enable_if.hpp
@@ -0,0 +1,119 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+
+
+#ifndef BOOST_CORE_ENABLE_IF_HPP
+#define BOOST_CORE_ENABLE_IF_HPP
+
+#include "boost/config.hpp"
+
+// Even the definition of enable_if causes problems on some compilers,
+// so it's macroed out for all compilers that do not support SFINAE
+
+#ifndef BOOST_NO_SFINAE
+
+namespace boost
+{
+ 
+  template 
+  struct enable_if_c {
+    typedef T type;
+  };
+
+  template 
+  struct enable_if_c {};
+
+  template  
+  struct enable_if : public enable_if_c {};
+
+  template 
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+
+  template 
+  struct lazy_enable_if_c {};
+
+  template  
+  struct lazy_enable_if : public lazy_enable_if_c {};
+
+
+  template 
+  struct disable_if_c {
+    typedef T type;
+  };
+
+  template 
+  struct disable_if_c {};
+
+  template  
+  struct disable_if : public disable_if_c {};
+
+  template 
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+
+  template 
+  struct lazy_disable_if_c {};
+
+  template  
+  struct lazy_disable_if : public lazy_disable_if_c {};
+
+} // namespace boost
+
+#else
+
+namespace boost {
+
+  namespace detail { typedef void enable_if_default_T; }
+
+  template 
+  struct enable_if_does_not_work_on_this_compiler;
+
+  template 
+  struct enable_if_c : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct disable_if_c : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct enable_if : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct disable_if : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler
+  { };
+
+  template  
+  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler
+  { };
+
+} // namespace boost
+
+#endif // BOOST_NO_SFINAE
+
+#endif
diff --git a/libktorrent/miniboost/boost/core/no_exceptions_support.hpp b/libktorrent/miniboost/boost/core/no_exceptions_support.hpp
new file mode 100644
index 00000000..a697f01a
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/no_exceptions_support.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+//----------------------------------------------------------------------
+// (C) Copyright 2004 Pavel Vozenilek.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//
+// This file contains helper macros used when exception support may be
+// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+//
+// Before picking up these macros you may consider using RAII techniques
+// to deal with exceptions - their syntax can be always the same with 
+// or without exception support enabled.
+//----------------------------------------------------------------------
+
+#include 
+#include 
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_TRY { try
+#    define BOOST_CATCH(x) catch(x)
+#    define BOOST_RETHROW throw;
+#    define BOOST_CATCH_END }
+#else
+#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#        define BOOST_TRY { if ("")
+#        define BOOST_CATCH(x) else if (!"")
+#    else
+#        define BOOST_TRY { if (true)
+#        define BOOST_CATCH(x) else if (false)
+#    endif
+#    define BOOST_RETHROW
+#    define BOOST_CATCH_END }
+#endif
+
+
+#endif 
diff --git a/libktorrent/miniboost/boost/core/noncopyable.hpp b/libktorrent/miniboost/boost/core/noncopyable.hpp
new file mode 100644
index 00000000..6ae8c244
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/noncopyable.hpp
@@ -0,0 +1,48 @@
+//  Boost noncopyable.hpp header file  --------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/utility for documentation.
+
+#ifndef BOOST_CORE_NONCOPYABLE_HPP
+#define BOOST_CORE_NONCOPYABLE_HPP
+
+#include 
+
+namespace boost {
+
+//  Private copy constructor and copy assignment ensure classes derived from
+//  class noncopyable cannot be copied.
+
+//  Contributed by Dave Abrahams
+
+namespace noncopyable_  // protection from unintended ADL
+{
+  class noncopyable
+  {
+  protected:
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+      BOOST_CONSTEXPR noncopyable() = default;
+      ~noncopyable() = default;
+#else
+      noncopyable() {}
+      ~noncopyable() {}
+#endif
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+      noncopyable( const noncopyable& ) = delete;
+      noncopyable& operator=( const noncopyable& ) = delete;
+#else
+  private:  // emphasize the following members are private
+      noncopyable( const noncopyable& );
+      noncopyable& operator=( const noncopyable& );
+#endif
+  };
+}
+
+typedef noncopyable_::noncopyable noncopyable;
+
+} // namespace boost
+
+#endif  // BOOST_CORE_NONCOPYABLE_HPP
diff --git a/libktorrent/miniboost/boost/core/typeinfo.hpp b/libktorrent/miniboost/boost/core/typeinfo.hpp
new file mode 100644
index 00000000..e67b4a31
--- /dev/null
+++ b/libktorrent/miniboost/boost/core/typeinfo.hpp
@@ -0,0 +1,151 @@
+#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
+#define BOOST_CORE_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  core::typeinfo, BOOST_CORE_TYPEID
+//
+//  Copyright 2007, 2014 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include 
+
+#if defined( BOOST_NO_TYPEID )
+
+#include 
+#include 
+
+namespace boost
+{
+
+namespace core
+{
+
+class typeinfo
+{
+private:
+
+    typeinfo( typeinfo const& );
+    typeinfo& operator=( typeinfo const& );
+
+    char const * name_;
+
+public:
+
+    explicit typeinfo( char const * name ): name_( name )
+    {
+    }
+
+    bool operator==( typeinfo const& rhs ) const
+    {
+        return this == &rhs;
+    }
+
+    bool operator!=( typeinfo const& rhs ) const
+    {
+        return this != &rhs;
+    }
+
+    bool before( typeinfo const& rhs ) const
+    {
+        return std::less< typeinfo const* >()( this, &rhs );
+    }
+
+    char const* name() const
+    {
+        return name_;
+    }
+};
+
+inline char const * demangled_name( core::typeinfo const & ti )
+{
+    return ti.name();
+}
+
+} // namespace core
+
+namespace detail
+{
+
+template struct core_typeid_
+{
+    static boost::core::typeinfo ti_;
+
+    static char const * name()
+    {
+        return BOOST_CURRENT_FUNCTION;
+    }
+};
+
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization 
+// constructor arguments. But an assignment works just fine. 
+template boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
+#else
+template boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
+#endif
+
+template struct core_typeid_< T & >: core_typeid_< T >
+{
+};
+
+template struct core_typeid_< T const >: core_typeid_< T >
+{
+};
+
+template struct core_typeid_< T volatile >: core_typeid_< T >
+{
+};
+
+template struct core_typeid_< T const volatile >: core_typeid_< T >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_::ti_)
+
+#else
+
+#include 
+#include 
+
+namespace boost
+{
+
+namespace core
+{
+
+#if defined( BOOST_NO_STD_TYPEINFO )
+
+typedef ::type_info typeinfo;
+
+#else
+
+typedef std::type_info typeinfo;
+
+#endif
+
+inline std::string demangled_name( core::typeinfo const & ti )
+{
+    return core::demangle( ti.name() );
+}
+
+} // namespace core
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) typeid(T)
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
diff --git a/libktorrent/miniboost/boost/current_function.hpp b/libktorrent/miniboost/boost/current_function.hpp
new file mode 100644
index 00000000..5c113f80
--- /dev/null
+++ b/libktorrent/miniboost/boost/current_function.hpp
@@ -0,0 +1,71 @@
+#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/current_function.hpp - BOOST_CURRENT_FUNCTION
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+//  http://www.boost.org/libs/assert/current_function.html
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void current_function_helper()
+{
+
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__FUNCSIG__)
+
+# define BOOST_CURRENT_FUNCTION __FUNCSIG__
+
+#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
+
+# define BOOST_CURRENT_FUNCTION __FUNCTION__
+
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
+
+# define BOOST_CURRENT_FUNCTION __FUNC__
+
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+
+# define BOOST_CURRENT_FUNCTION __func__
+
+#elif defined(__cplusplus) && (__cplusplus >= 201103)
+
+# define BOOST_CURRENT_FUNCTION __func__
+
+#else
+
+# define BOOST_CURRENT_FUNCTION "(unknown)"
+
+#endif
+
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
diff --git a/libktorrent/miniboost/boost/detail/call_traits.hpp b/libktorrent/miniboost/boost/detail/call_traits.hpp
new file mode 100644
index 00000000..36dea000
--- /dev/null
+++ b/libktorrent/miniboost/boost/detail/call_traits.hpp
@@ -0,0 +1,172 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
+
+// call_traits: defines typedefs for function usage
+// (see libs/utility/call_traits.htm)
+
+/* Release notes:
+   23rd July 2000:
+      Fixed array specialization. (JM)
+      Added Borland specific fixes for reference types
+      (issue raised by Steve Cleary).
+*/
+
+#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
+#define BOOST_DETAIL_CALL_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include 
+#endif
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+namespace boost{
+
+namespace detail{
+
+template 
+struct ct_imp2
+{
+   typedef const T& param_type;
+};
+
+template 
+struct ct_imp2
+{
+   typedef const T param_type;
+};
+
+template 
+struct ct_imp
+{
+   typedef const T& param_type;
+};
+
+template 
+struct ct_imp
+{
+   typedef typename ct_imp2::param_type param_type;
+};
+
+template 
+struct ct_imp
+{
+   typedef typename ct_imp2::param_type param_type;
+};
+
+template 
+struct ct_imp
+{
+   typedef const T param_type;
+};
+
+}
+
+template 
+struct call_traits
+{
+public:
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   //
+   // C++ Builder workaround: we should be able to define a compile time
+   // constant and pass that as a single template parameter to ct_imp,
+   // however compiler bugs prevent this - instead pass three bool's to
+   // ct_imp and add an extra partial specialisation
+   // of ct_imp to handle the logic. (JM)
+   typedef typename boost::detail::ct_imp<
+      T,
+      ::boost::is_pointer::value,
+      ::boost::is_arithmetic::value,
+      ::boost::is_enum::value
+   >::param_type param_type;
+};
+
+template 
+struct call_traits
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+
+#if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
+// these are illegal specialisations; cv-qualifies applied to
+// references have no effect according to [8.3.2p1],
+// C++ Builder requires them though as it treats cv-qualified
+// references as distinct types...
+template 
+struct call_traits
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+template 
+struct call_traits
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+template 
+struct call_traits
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;  // hh removed const
+};
+
+template 
+struct call_traits< T * >
+{
+   typedef T * value_type;
+   typedef T * & reference;
+   typedef T * const & const_reference;
+   typedef T * const param_type;  // hh removed const
+};
+#endif
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+template 
+struct call_traits
+{
+private:
+   typedef T array_type[N];
+public:
+   // degrades array to pointer:
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+
+template 
+struct call_traits
+{
+private:
+   typedef const T array_type[N];
+public:
+   // degrades array to pointer:
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+#endif
+
+}
+
+#endif // BOOST_DETAIL_CALL_TRAITS_HPP
diff --git a/libktorrent/miniboost/boost/detail/indirect_traits.hpp b/libktorrent/miniboost/boost/detail/indirect_traits.hpp
new file mode 100644
index 00000000..7c8f76b0
--- /dev/null
+++ b/libktorrent/miniboost/boost/detail/indirect_traits.hpp
@@ -0,0 +1,205 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef INDIRECT_TRAITS_DWA2002131_HPP
+# define INDIRECT_TRAITS_DWA2002131_HPP
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+
+# include 
+# include 
+
+# include 
+# include 
+# include 
+# include 
+# include 
+# include 
+
+
+namespace boost { namespace detail {
+
+namespace indirect_traits {
+
+template 
+struct is_reference_to_const : mpl::false_
+{
+};
+
+template 
+struct is_reference_to_const : mpl::true_
+{
+};
+
+#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+template
+struct is_reference_to_const : mpl::true_
+{
+};
+#   endif 
+
+template 
+struct is_reference_to_function : mpl::false_
+{
+};
+
+template 
+struct is_reference_to_function : is_function
+{
+};
+
+template 
+struct is_pointer_to_function : mpl::false_
+{
+};
+
+// There's no such thing as a pointer-to-cv-function, so we don't need
+// specializations for those
+template 
+struct is_pointer_to_function : is_function
+{
+};
+
+template 
+struct is_reference_to_member_function_pointer_impl : mpl::false_
+{
+};
+
+template 
+struct is_reference_to_member_function_pointer_impl
+    : is_member_function_pointer::type>
+{
+};
+
+
+template 
+struct is_reference_to_member_function_pointer
+    : is_reference_to_member_function_pointer_impl
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
+};
+
+template 
+struct is_reference_to_function_pointer_aux
+    : mpl::and_<
+          is_reference
+        , is_pointer_to_function<
+              typename remove_cv<
+                  typename remove_reference::type
+              >::type
+          >
+      >
+{
+    // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
+};
+
+template 
+struct is_reference_to_function_pointer
+    : mpl::if_<
+          is_reference_to_function
+        , mpl::false_
+        , is_reference_to_function_pointer_aux
+     >::type
+{
+};
+
+template 
+struct is_reference_to_non_const
+    : mpl::and_<
+          is_reference
+        , mpl::not_<
+             is_reference_to_const
+          >
+      >
+{
+};
+
+template 
+struct is_reference_to_volatile : mpl::false_
+{
+};
+
+template 
+struct is_reference_to_volatile : mpl::true_
+{
+};
+
+#   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+template 
+struct is_reference_to_volatile : mpl::true_
+{
+};
+#   endif 
+
+
+template 
+struct is_reference_to_pointer : mpl::false_
+{
+};
+
+template 
+struct is_reference_to_pointer : mpl::true_
+{
+};
+
+template 
+struct is_reference_to_pointer : mpl::true_
+{
+};
+
+template 
+struct is_reference_to_pointer : mpl::true_
+{
+};
+
+template 
+struct is_reference_to_pointer : mpl::true_
+{
+};
+
+template 
+struct is_reference_to_class
+    : mpl::and_<
+          is_reference
+        , is_class<
+              typename remove_cv<
+                  typename remove_reference::type
+              >::type
+          >
+      >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
+};
+
+template 
+struct is_pointer_to_class
+    : mpl::and_<
+          is_pointer
+        , is_class<
+              typename remove_cv<
+                  typename remove_pointer::type
+              >::type
+          >
+      >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
+};
+
+
+}
+
+using namespace indirect_traits;
+
+}} // namespace boost::python::detail
+
+#endif // INDIRECT_TRAITS_DWA2002131_HPP
diff --git a/libktorrent/miniboost/boost/detail/iterator.hpp b/libktorrent/miniboost/boost/detail/iterator.hpp
new file mode 100644
index 00000000..c2e8f1e2
--- /dev/null
+++ b/libktorrent/miniboost/boost/detail/iterator.hpp
@@ -0,0 +1,26 @@
+// (C) Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef ITERATOR_DWA122600_HPP_
+#define ITERATOR_DWA122600_HPP_
+
+// This header is obsolete and will be deprecated.
+
+#include 
+
+namespace boost
+{
+
+namespace detail
+{
+
+using std::iterator_traits;
+using std::distance;
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // ITERATOR_DWA122600_HPP_
diff --git a/libktorrent/miniboost/boost/detail/no_exceptions_support.hpp b/libktorrent/miniboost/boost/detail/no_exceptions_support.hpp
new file mode 100644
index 00000000..7d17454a
--- /dev/null
+++ b/libktorrent/miniboost/boost/detail/no_exceptions_support.hpp
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP
+#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP
+
+// The header file at this path is deprecated;
+// use boost/core/no_exceptions_support.hpp instead.
+
+#include 
+
+#endif
diff --git a/libktorrent/miniboost/boost/detail/sp_typeinfo.hpp b/libktorrent/miniboost/boost/detail/sp_typeinfo.hpp
new file mode 100644
index 00000000..4e4de55b
--- /dev/null
+++ b/libktorrent/miniboost/boost/detail/sp_typeinfo.hpp
@@ -0,0 +1,36 @@
+#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/sp_typeinfo.hpp
+//
+//  Deprecated, please use boost/core/typeinfo.hpp
+//
+//  Copyright 2007 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include 
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef boost::core::typeinfo sp_typeinfo;
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID(T) BOOST_CORE_TYPEID(T)
+
+#endif  // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
diff --git a/libktorrent/miniboost/boost/detail/workaround.hpp b/libktorrent/miniboost/boost/detail/workaround.hpp
new file mode 100644
index 00000000..40b3423b
--- /dev/null
+++ b/libktorrent/miniboost/boost/detail/workaround.hpp
@@ -0,0 +1,267 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef WORKAROUND_DWA2002126_HPP
+# define WORKAROUND_DWA2002126_HPP
+
+// Compiler/library version workaround macro
+//
+// Usage:
+//
+//     #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+//        // workaround for eVC4 and VC6
+//        ... // workaround code here
+//     #endif
+//
+// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
+// first argument must be undefined or expand to a numeric
+// value. The above expands to:
+//
+//     (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
+//
+// When used for workarounds that apply to the latest known version 
+// and all earlier versions of a compiler, the following convention 
+// should be observed:
+//
+//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
+//
+// The version number in this case corresponds to the last version in
+// which the workaround was known to have been required. When
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
+// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
+// the workaround for any version of the compiler. When
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
+// error will be issued if the compiler version exceeds the argument
+// to BOOST_TESTED_AT().  This can be used to locate workarounds which
+// may be obsoleted by newer versions.
+
+# ifndef BOOST_STRICT_CONFIG
+
+#include 
+
+#ifndef __BORLANDC__
+#define __BORLANDC___WORKAROUND_GUARD 1
+#else
+#define __BORLANDC___WORKAROUND_GUARD 0
+#endif
+#ifndef __CODEGEARC__
+#define __CODEGEARC___WORKAROUND_GUARD 1
+#else
+#define __CODEGEARC___WORKAROUND_GUARD 0
+#endif
+#ifndef _MSC_VER
+#define _MSC_VER_WORKAROUND_GUARD 1
+#else
+#define _MSC_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef _MSC_FULL_VER
+#define _MSC_FULL_VER_WORKAROUND_GUARD 1
+#else
+#define _MSC_FULL_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_MSVC
+#define BOOST_MSVC_WORKAROUND_GUARD 1
+#else
+#define BOOST_MSVC_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_MSVC_FULL_VER
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __GNUC__
+#define __GNUC___WORKAROUND_GUARD 1
+#else
+#define __GNUC___WORKAROUND_GUARD 0
+#endif
+#ifndef __GNUC_MINOR__
+#define __GNUC_MINOR___WORKAROUND_GUARD 1
+#else
+#define __GNUC_MINOR___WORKAROUND_GUARD 0
+#endif
+#ifndef __GNUC_PATCHLEVEL__
+#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
+#else
+#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
+#endif
+#ifndef __IBMCPP__
+#define __IBMCPP___WORKAROUND_GUARD 1
+#else
+#define __IBMCPP___WORKAROUND_GUARD 0
+#endif
+#ifndef __SUNPRO_CC
+#define __SUNPRO_CC_WORKAROUND_GUARD 1
+#else
+#define __SUNPRO_CC_WORKAROUND_GUARD 0
+#endif
+#ifndef __DECCXX_VER
+#define __DECCXX_VER_WORKAROUND_GUARD 1
+#else
+#define __DECCXX_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __MWERKS__
+#define __MWERKS___WORKAROUND_GUARD 1
+#else
+#define __MWERKS___WORKAROUND_GUARD 0
+#endif
+#ifndef __EDG__
+#define __EDG___WORKAROUND_GUARD 1
+#else
+#define __EDG___WORKAROUND_GUARD 0
+#endif
+#ifndef __EDG_VERSION__
+#define __EDG_VERSION___WORKAROUND_GUARD 1
+#else
+#define __EDG_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef __HP_aCC
+#define __HP_aCC_WORKAROUND_GUARD 1
+#else
+#define __HP_aCC_WORKAROUND_GUARD 0
+#endif
+#ifndef __hpxstd98
+#define __hpxstd98_WORKAROUND_GUARD 1
+#else
+#define __hpxstd98_WORKAROUND_GUARD 0
+#endif
+#ifndef _CRAYC
+#define _CRAYC_WORKAROUND_GUARD 1
+#else
+#define _CRAYC_WORKAROUND_GUARD 0
+#endif
+#ifndef __DMC__
+#define __DMC___WORKAROUND_GUARD 1
+#else
+#define __DMC___WORKAROUND_GUARD 0
+#endif
+#ifndef MPW_CPLUS
+#define MPW_CPLUS_WORKAROUND_GUARD 1
+#else
+#define MPW_CPLUS_WORKAROUND_GUARD 0
+#endif
+#ifndef __COMO__
+#define __COMO___WORKAROUND_GUARD 1
+#else
+#define __COMO___WORKAROUND_GUARD 0
+#endif
+#ifndef __COMO_VERSION__
+#define __COMO_VERSION___WORKAROUND_GUARD 1
+#else
+#define __COMO_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef __INTEL_COMPILER
+#define __INTEL_COMPILER_WORKAROUND_GUARD 1
+#else
+#define __INTEL_COMPILER_WORKAROUND_GUARD 0
+#endif
+#ifndef __ICL
+#define __ICL_WORKAROUND_GUARD 1
+#else
+#define __ICL_WORKAROUND_GUARD 0
+#endif
+#ifndef _COMPILER_VERSION
+#define _COMPILER_VERSION_WORKAROUND_GUARD 1
+#else
+#define _COMPILER_VERSION_WORKAROUND_GUARD 0
+#endif
+
+#ifndef _RWSTD_VER
+#define _RWSTD_VER_WORKAROUND_GUARD 1
+#else
+#define _RWSTD_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_RWSTD_VER
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __GLIBCPP__
+#define __GLIBCPP___WORKAROUND_GUARD 1
+#else
+#define __GLIBCPP___WORKAROUND_GUARD 0
+#endif
+#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
+#else
+#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
+#endif
+#ifndef __SGI_STL_PORT
+#define __SGI_STL_PORT_WORKAROUND_GUARD 1
+#else
+#define __SGI_STL_PORT_WORKAROUND_GUARD 0
+#endif
+#ifndef _STLPORT_VERSION
+#define _STLPORT_VERSION_WORKAROUND_GUARD 1
+#else
+#define _STLPORT_VERSION_WORKAROUND_GUARD 0
+#endif
+#ifndef __LIBCOMO_VERSION__
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
+#else
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef _CPPLIB_VER
+#define _CPPLIB_VER_WORKAROUND_GUARD 1
+#else
+#define _CPPLIB_VER_WORKAROUND_GUARD 0
+#endif
+
+#ifndef BOOST_INTEL_CXX_VERSION
+#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
+#else
+#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_INTEL_WIN
+#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
+#else
+#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_DINKUMWARE_STDLIB
+#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
+#else
+#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_INTEL
+#define BOOST_INTEL_WORKAROUND_GUARD 1
+#else
+#define BOOST_INTEL_WORKAROUND_GUARD 0
+#endif
+// Always define to zero, if it's used it'll be defined my MPL:
+#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
+
+#  define BOOST_WORKAROUND(symbol, test)                \
+         ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
+         (symbol != 0) && (1 % (( (symbol test) ) + 1)))
+//                              ^ ^           ^ ^
+// The extra level of parenthesis nesting above, along with the
+// BOOST_OPEN_PAREN indirection below, is required to satisfy the
+// broken preprocessor in MWCW 8.3 and earlier.
+//
+// The basic mechanism works as follows:
+//      (symbol test) + 1        =>   if (symbol test) then 2 else 1
+//      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
+//
+// The complication with % is for cooperation with BOOST_TESTED_AT().
+// When "test" is BOOST_TESTED_AT(x) and
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
+//
+//      symbol test              =>   if (symbol <= x) then 1 else -1
+//      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
+//      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
+//
+
+#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
+#   define BOOST_OPEN_PAREN (
+#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
+#  else
+#   define BOOST_TESTED_AT(value) != ((value)-(value))
+#  endif
+
+# else
+
+#  define BOOST_WORKAROUND(symbol, test) 0
+
+# endif 
+
+#endif // WORKAROUND_DWA2002126_HPP
diff --git a/libktorrent/miniboost/boost/exception/exception.hpp b/libktorrent/miniboost/boost/exception/exception.hpp
new file mode 100644
index 00000000..d762cf82
--- /dev/null
+++ b/libktorrent/miniboost/boost/exception/exception.hpp
@@ -0,0 +1,489 @@
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+
+//Distributed under the Boost Software License, Version 1.0. (See accompanying
+//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef UUID_274DA366004E11DCB1DDFE2E56D89593
+#define UUID_274DA366004E11DCB1DDFE2E56D89593
+#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template 
+        class
+        refcount_ptr
+            {
+            public:
+
+            refcount_ptr():
+                px_(0)
+                {
+                }
+
+            ~refcount_ptr()
+                {
+                release();
+                }
+
+            refcount_ptr( refcount_ptr const & x ):
+                px_(x.px_)
+                {
+                add_ref();
+                }
+
+            refcount_ptr &
+            operator=( refcount_ptr const & x )
+                {
+                adopt(x.px_);
+                return *this;
+                }
+
+            void
+            adopt( T * px )
+                {
+                release();
+                px_=px;
+                add_ref();
+                }
+
+            T *
+            get() const
+                {
+                return px_;
+                }
+
+            private:
+
+            T * px_;
+
+            void
+            add_ref()
+                {
+                if( px_ )
+                    px_->add_ref();
+                }
+
+            void
+            release()
+                {
+                if( px_ && px_->release() )
+                    px_=0;
+                }
+            };
+        }
+
+    ////////////////////////////////////////////////////////////////////////
+
+    template 
+    class error_info;
+
+    typedef error_info throw_function;
+    typedef error_info throw_file;
+    typedef error_info throw_line;
+
+    template <>
+    class
+    error_info
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <>
+    class
+    error_info
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <>
+    class
+    error_info
+        {
+        public:
+        typedef int value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
+    class exception;
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
+
+    template 
+    class shared_ptr;
+
+    namespace
+    exception_detail
+        {
+        class error_info_base;
+        struct type_info_;
+
+        struct
+        error_info_container
+            {
+            virtual char const * diagnostic_information( char const * ) const = 0;
+            virtual shared_ptr get( type_info_ const & ) const = 0;
+            virtual void set( shared_ptr const &, type_info_ const & ) = 0;
+            virtual void add_ref() const = 0;
+            virtual bool release() const = 0;
+            virtual refcount_ptr clone() const = 0;
+
+            protected:
+
+            ~error_info_container() throw()
+                {
+                }
+            };
+
+        template 
+        struct get_info;
+
+        template <>
+        struct get_info;
+
+        template <>
+        struct get_info;
+
+        template <>
+        struct get_info;
+
+        char const * get_diagnostic_information( exception const &, char const * );
+
+        void copy_boost_exception( exception *, exception const * );
+
+        template 
+        E const & set_info( E const &, error_info const & );
+
+        template 
+        E const & set_info( E const &, throw_function const & );
+
+        template 
+        E const & set_info( E const &, throw_file const & );
+
+        template 
+        E const & set_info( E const &, throw_line const & );
+        }
+
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
+    class
+    exception
+        {
+        //
+        public:
+        template  void set( typename Tag::type const & );
+        template  typename Tag::type const * get() const;
+        //
+
+        protected:
+
+        exception():
+            throw_function_(0),
+            throw_file_(0),
+            throw_line_(-1)
+            {
+            }
+
+#ifdef __HP_aCC
+        //On HP aCC, this protected copy constructor prevents throwing boost::exception.
+        //On all other platforms, the same effect is achieved by the pure virtual destructor.
+        exception( exception const & x ) throw():
+            data_(x.data_),
+            throw_function_(x.throw_function_),
+            throw_file_(x.throw_file_),
+            throw_line_(x.throw_line_)
+            {
+            }
+#endif
+
+        virtual ~exception() throw()
+#ifndef __HP_aCC
+            = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors.
+#endif
+            ;
+
+#if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
+        public:
+#else
+        private:
+
+        template 
+        friend E const & exception_detail::set_info( E const &, throw_function const & );
+
+        template 
+        friend E const & exception_detail::set_info( E const &, throw_file const & );
+
+        template 
+        friend E const & exception_detail::set_info( E const &, throw_line const & );
+
+        template 
+        friend E const & exception_detail::set_info( E const &, error_info const & );
+
+        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+
+        template 
+        friend struct exception_detail::get_info;
+        friend struct exception_detail::get_info;
+        friend struct exception_detail::get_info;
+        friend struct exception_detail::get_info;
+        friend void exception_detail::copy_boost_exception( exception *, exception const * );
+#endif
+        mutable exception_detail::refcount_ptr data_;
+        mutable char const * throw_function_;
+        mutable char const * throw_file_;
+        mutable int throw_line_;
+        };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
+
+    inline
+    exception::
+    ~exception() throw()
+        {
+        }
+
+    namespace
+    exception_detail
+        {
+        template 
+        E const &
+        set_info( E const & x, throw_function const & y )
+            {
+            x.throw_function_=y.v_;
+            return x;
+            }
+
+        template 
+        E const &
+        set_info( E const & x, throw_file const & y )
+            {
+            x.throw_file_=y.v_;
+            return x;
+            }
+
+        template 
+        E const &
+        set_info( E const & x, throw_line const & y )
+            {
+            x.throw_line_=y.v_;
+            return x;
+            }
+        }
+
+    ////////////////////////////////////////////////////////////////////////
+
+    namespace
+    exception_detail
+        {
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
+        template 
+        struct
+        error_info_injector:
+            public T,
+            public exception
+            {
+            explicit
+            error_info_injector( T const & x ):
+                T(x)
+                {
+                }
+
+            ~error_info_injector() throw()
+                {
+                }
+            };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
+
+        struct large_size { char c[256]; };
+        large_size dispatch_boost_exception( exception const * );
+
+        struct small_size { };
+        small_size dispatch_boost_exception( void const * );
+
+        template 
+        struct enable_error_info_helper;
+
+        template 
+        struct
+        enable_error_info_helper
+            {
+            typedef T type;
+            };
+
+        template 
+        struct
+        enable_error_info_helper
+            {
+            typedef error_info_injector type;
+            };
+
+        template 
+        struct
+        enable_error_info_return_type
+            {
+            typedef typename enable_error_info_helper(0)))>::type type;
+            };
+        }
+
+    template 
+    inline
+    typename
+    exception_detail::enable_error_info_return_type::type
+    enable_error_info( T const & x )
+        {
+        typedef typename exception_detail::enable_error_info_return_type::type rt;
+        return rt(x);
+        }
+
+    ////////////////////////////////////////////////////////////////////////
+
+    namespace
+    exception_detail
+        {
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
+        class
+        clone_base
+            {
+            public:
+
+            virtual clone_base const * clone() const = 0;
+            virtual void rethrow() const = 0;
+
+            virtual
+            ~clone_base() throw()
+                {
+                }
+            };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
+
+        inline
+        void
+        copy_boost_exception( exception * a, exception const * b )
+            {
+            refcount_ptr data;
+            if( error_info_container * d=b->data_.get() )
+                data = d->clone();
+            a->throw_file_ = b->throw_file_;
+            a->throw_line_ = b->throw_line_;
+            a->throw_function_ = b->throw_function_;
+            a->data_ = data;
+            }
+
+        inline
+        void
+        copy_boost_exception( void *, void const * )
+            {
+            }
+
+        template 
+        class
+        clone_impl:
+            public T,
+            public virtual clone_base
+            {
+            struct clone_tag { };
+            clone_impl( clone_impl const & x, clone_tag ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+
+            public:
+
+            explicit
+            clone_impl( T const & x ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+
+            ~clone_impl() throw()
+                {
+                }
+
+            private:
+
+            clone_base const *
+            clone() const
+                {
+                return new clone_impl(*this,clone_tag());
+                }
+
+            void
+            rethrow() const
+                {
+                throw*this;
+                }
+            };
+        }
+
+    template 
+    inline
+    exception_detail::clone_impl
+    enable_current_exception( T const & x )
+        {
+        return exception_detail::clone_impl(x);
+        }
+    }
+
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(pop)
+#endif
+#endif
diff --git a/libktorrent/miniboost/boost/intrusive/detail/config_begin.hpp b/libktorrent/miniboost/boost/intrusive/detail/config_begin.hpp
new file mode 100644
index 00000000..109a5908
--- /dev/null
+++ b/libktorrent/miniboost/boost/intrusive/detail/config_begin.hpp
@@ -0,0 +1,52 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2006-2013
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_CONFIG_INCLUDED
+#define BOOST_INTRUSIVE_CONFIG_INCLUDED
+#include 
+#endif
+
+#ifdef BOOST_MSVC
+
+   #pragma warning (push)
+   //
+   //'function' : resolved overload was found by argument-dependent lookup
+   //A function found by argument-dependent lookup (Koenig lookup) was eventually
+   //chosen by overload resolution.
+   //
+   //In Visual C++ .NET and earlier compilers, a different function would have
+   //been called. To pick the original function, use an explicitly qualified name.
+   //
+
+   //warning C4275: non dll-interface class 'x' used as base for
+   //dll-interface class 'Y'
+   #pragma warning (disable : 4275)
+   //warning C4251: 'x' : class 'y' needs to have dll-interface to
+   //be used by clients of class 'z'
+   #pragma warning (disable : 4251)
+   #pragma warning (disable : 4675)
+   #pragma warning (disable : 4996)
+   #pragma warning (disable : 4503)
+   #pragma warning (disable : 4284) // odd return type for operator->
+   #pragma warning (disable : 4244) // possible loss of data
+   #pragma warning (disable : 4521) ////Disable "multiple copy constructors specified"
+   #pragma warning (disable : 4522)
+   #pragma warning (disable : 4146)
+   #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
+   #pragma warning (disable : 4127) //conditional expression is constant
+   #pragma warning (disable : 4706) //assignment within conditional expression
+   #pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR-
+   #pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR-
+#endif
+
+//#define BOOST_INTRUSIVE_USE_ITERATOR_FACADE
+//#define BOOST_INTRUSIVE_USE_ITERATOR_ENABLE_IF_CONVERTIBLE
diff --git a/libktorrent/miniboost/boost/intrusive/detail/config_end.hpp b/libktorrent/miniboost/boost/intrusive/detail/config_end.hpp
new file mode 100644
index 00000000..a081443e
--- /dev/null
+++ b/libktorrent/miniboost/boost/intrusive/detail/config_end.hpp
@@ -0,0 +1,15 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2006-2013
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined BOOST_MSVC
+   #pragma warning (pop)
+#endif
diff --git a/libktorrent/miniboost/boost/intrusive/detail/has_member_function_callable_with.hpp b/libktorrent/miniboost/boost/intrusive/detail/has_member_function_callable_with.hpp
new file mode 100644
index 00000000..12eec962
--- /dev/null
+++ b/libktorrent/miniboost/boost/intrusive/detail/has_member_function_callable_with.hpp
@@ -0,0 +1,380 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+// sample.h
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+   #ifndef BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED
+   #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED
+
+      #include 
+      #include 
+      #include 
+      #include 
+      #include 
+      #include 
+
+      //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
+      //wrong SFINAE for GCC 4.2/4.3
+      #if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430)
+      #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+      #elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200 )
+      #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+      #endif
+
+      namespace boost_intrusive_has_member_function_callable_with {
+
+      struct dont_care
+      {
+         dont_care(...);
+      };
+
+      struct private_type
+      {
+         static private_type p;
+         private_type const &operator,(int) const;
+      };
+
+      typedef char yes_type;            // sizeof(yes_type) == 1
+      struct no_type{ char dummy[2]; }; // sizeof(no_type)  == 2
+
+      template
+      no_type is_private_type(T const &);
+      yes_type is_private_type(private_type const &);
+
+      }  //boost_intrusive_has_member_function_callable_with
+
+      #include 
+
+   #endif   //BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED
+
+#else //!BOOST_PP_IS_ITERATING
+
+   #ifndef  BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+   #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME not defined!"
+   #endif
+
+   #ifndef  BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
+   #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN not defined!"
+   #endif
+
+   #ifndef  BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+   #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!"
+   #endif
+
+   #if BOOST_PP_ITERATION_START() > BOOST_PP_ITERATION_FINISH()
+   #error "BOOST_PP_ITERATION_START() must be <= BOOST_PP_ITERATION_FINISH()"
+   #endif
+
+   #if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_START()
+
+      BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
+
+      template 
+      class BOOST_PP_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+      {
+         struct BaseMixin
+         {
+            void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME();
+         };
+
+         struct Base : public ::boost::intrusive::detail::remove_cv::type, public BaseMixin { Base(); };
+         template  class Helper{};
+
+         template 
+         static boost_intrusive_has_member_function_callable_with::no_type  deduce
+            (U*, Helper* = 0);
+         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);
+
+         public:
+         static const bool value =
+            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
+      };
+
+      #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+         template
+         struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl);
+         //!
+
+         template
+         struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl)
+            
+         {
+            static const bool value = false;
+         };
+         //!
+
+      #else //!defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+         template
+         struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl);
+
+         template
+         struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+            
+         {
+            static const bool value = false;
+         };
+
+         #ifdef BOOST_NO_CXX11_DECLTYPE
+
+         //Special case for 0 args
+         template< class F
+               , std::size_t N =
+                     sizeof((boost::move_detail::declval().
+                        BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))>
+         struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+         {
+            boost_intrusive_has_member_function_callable_with::yes_type dummy;
+            BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
+         };
+
+         //For buggy compilers like MSVC 7.1+ ((F*)0)->func() does not
+         //SFINAE-out the zeroarg_checker_ instantiation but sizeof yields to 0.
+         template
+         struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+         {
+            boost_intrusive_has_member_function_callable_with::no_type dummy;
+            BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
+         };
+
+         #endif   //#ifdef BOOST_NO_CXX11_DECLTYPE
+
+         template
+         struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+            
+         {
+            #ifndef BOOST_NO_CXX11_DECLTYPE
+            template().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()) >
+            static boost_intrusive_has_member_function_callable_with::yes_type Test(U*);
+            #else
+            template
+               static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+                Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)*);
+            #endif
+   
+            template 
+            static boost_intrusive_has_member_function_callable_with::no_type Test(...);
+
+            static const bool value = sizeof(Test< Fun >(0))
+                                 == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
+         };
+
+         template
+         struct BOOST_PP_CAT( funwrap_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )
+            : Fun
+         {
+            BOOST_PP_CAT( funwrap_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )();
+            using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
+
+            boost_intrusive_has_member_function_callable_with::private_type
+               BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+                  ( DontCares...)  const;
+         };
+
+         template
+         struct BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl)
+            
+         {
+            template
+            struct make_dontcare
+            {
+               typedef boost_intrusive_has_member_function_callable_with::dont_care type;
+            };
+
+            typedef BOOST_PP_CAT( funwrap_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )
+               ::type...> FunWrap;
+
+            static bool const value = (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
+                                       sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
+                                                ( (::boost::move_detail::declval< FunWrap >().
+                                          BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+                                             ( ::boost::move_detail::declval()... ), 0) )
+                                             )
+                                       );
+         };
+
+         template
+         struct BOOST_PP_CAT( has_member_function_callable_with_
+                            , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+            : public BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_
+                                 , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+               < Fun
+               , BOOST_PP_CAT( has_member_function_named_
+                             , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )::value
+               , Args... >
+         {};
+
+      #endif   //!defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+      BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+
+   #endif   //BOOST_PP_ITERATION() == BOOST_PP_ITERATION_START()
+
+   #if BOOST_PP_ITERATION() == 0
+
+      BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
+
+      #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+         #if !defined(_MSC_VER) || (_MSC_VER < 1600)
+
+            #if defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
+
+            template
+            struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+               
+            {
+               //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
+               //wrong SFINAE for GCC 4.2/4.3
+               static const bool value = true;
+            };
+
+            #else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
+
+            //Special case for 0 args
+            template< class F
+                  , std::size_t N =
+                        sizeof((boost::move_detail::declval().
+                           BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))>
+            struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+            {
+               boost_intrusive_has_member_function_callable_with::yes_type dummy;
+               BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
+            };
+
+            //For buggy compilers like MSVC 7.1+ ((F*)0)->func() does not
+            //SFINAE-out the zeroarg_checker_ instantiation but sizeof yields to 0.
+            template
+            struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+            {
+               boost_intrusive_has_member_function_callable_with::no_type dummy;
+               BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
+            };
+
+            template
+            struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+               
+            {
+               template
+               static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+                  Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)*);
+
+               template 
+               static boost_intrusive_has_member_function_callable_with::no_type Test(...);
+
+               static const bool value = sizeof(Test< Fun >(0))
+                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
+            };
+            #endif   //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
+
+         #else //#if !defined(_MSC_VER) || (_MSC_VER < 1600)
+            template
+            struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+               
+            {
+               template
+               static decltype( boost::move_detail::declval().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
+                              , boost_intrusive_has_member_function_callable_with::yes_type())
+                  Test(U*);
+
+               template
+               static boost_intrusive_has_member_function_callable_with::no_type Test(...);
+
+               static const bool value = sizeof(Test(0))
+                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
+            };
+         #endif   //#if !defined(_MSC_VER) || (_MSC_VER < 1600)
+
+      #else   //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+      #endif   //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+      BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+
+   #else   //BOOST_PP_ITERATION() == 0
+
+      #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+         BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
+
+         template
+         struct BOOST_PP_CAT( BOOST_PP_CAT(funwrap, BOOST_PP_ITERATION())
+                           , BOOST_PP_CAT(_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME))
+            : Fun
+         {
+            BOOST_PP_CAT( BOOST_PP_CAT(funwrap, BOOST_PP_ITERATION())
+                        , BOOST_PP_CAT(_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME))();
+
+            using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
+            boost_intrusive_has_member_function_callable_with::private_type
+               BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+                  ( BOOST_PP_ENUM(BOOST_PP_ITERATION()
+                  , BOOST_INTRUSIVE_PP_IDENTITY
+                  , boost_intrusive_has_member_function_callable_with::dont_care))  const;
+         };
+
+         template
+         struct BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_
+                            , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
+            
+         {
+            typedef BOOST_PP_CAT( BOOST_PP_CAT(funwrap, BOOST_PP_ITERATION())
+                              , BOOST_PP_CAT(_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME))
+                     FunWrap;
+            static bool const value =
+            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
+               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
+                        (  (boost::move_detail::declval().
+                              BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+                                 ( BOOST_PP_ENUM( BOOST_PP_ITERATION(), BOOST_INTRUSIVE_PP_DECLVAL, _) ), 0
+                           )
+                        )
+                     )
+            );
+         };
+
+         BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+      #endif   //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+   #endif   //BOOST_PP_ITERATION() == 0
+
+   #if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_FINISH()
+
+      #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+         BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
+
+         template
+         struct BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+            : public BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl)
+               ::value
+               BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), P) >
+         {};
+
+         BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+
+      #endif //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING)
+
+      #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+      #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
+      #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+
+   #endif   //#if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_FINISH()
+
+#endif   //!BOOST_PP_IS_ITERATING
diff --git a/libktorrent/miniboost/boost/intrusive/detail/memory_util.hpp b/libktorrent/miniboost/boost/intrusive/detail/memory_util.hpp
new file mode 100644
index 00000000..49b69cff
--- /dev/null
+++ b/libktorrent/miniboost/boost/intrusive/detail/memory_util.hpp
@@ -0,0 +1,284 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Pablo Halpern 2009. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_ALLOCATOR_MEMORY_UTIL_HPP
+#define BOOST_INTRUSIVE_ALLOCATOR_MEMORY_UTIL_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+#include 
+#include 
+#include 
+#include 
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template 
+inline T* addressof(T& obj)
+{
+   return static_cast
+      (static_cast
+         (const_cast
+            (&reinterpret_cast(obj))
+         )
+      );
+}
+
+template  struct unvoid { typedef T type; };
+template <> struct unvoid { struct type { }; };
+template <> struct unvoid { struct type { }; };
+
+template  struct unvoid_ref { typedef T &type; };
+template <> struct unvoid_ref { struct type_impl { }; typedef type_impl & type; };
+template <> struct unvoid_ref { struct type_impl { }; typedef type_impl & type; };
+
+template 
+struct LowPriorityConversion
+{
+    // Convertible from T with user-defined-conversion rank.
+    LowPriorityConversion(const T&) { }
+};
+
+// Infrastructure for providing a default type for T::TNAME if absent.
+#define BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(TNAME)              \
+   template                              \
+   struct boost_intrusive_default_type_ ## TNAME                           \
+   {                                                                       \
+      template                                                 \
+      static char test(int, typename X::TNAME*);                           \
+                                                                           \
+      template                                                 \
+      static int test(...);                                                \
+                                                                           \
+      struct DefaultWrap { typedef DefaultType TNAME; };                   \
+                                                                           \
+      static const bool value = (1 == sizeof(test(0, 0)));              \
+                                                                           \
+      typedef typename                                                     \
+         ::boost::intrusive::detail::if_c                                  \
+            ::type::TNAME type;                     \
+   };                                                                      \
+                                                                           \
+   template                              \
+   struct boost_intrusive_eval_default_type_ ## TNAME                      \
+   {                                                                       \
+      template                                                 \
+      static char test(int, typename X::TNAME*);                           \
+                                                                           \
+      template                                                 \
+      static int test(...);                                                \
+                                                                           \
+      struct DefaultWrap                                                   \
+      { typedef typename DefaultType::type TNAME; };                       \
+                                                                           \
+      static const bool value = (1 == sizeof(test(0, 0)));              \
+                                                                           \
+      typedef typename                                                     \
+         ::boost::intrusive::detail::eval_if_c                             \
+            < value                                                        \
+            , ::boost::intrusive::detail::identity                      \
+            , ::boost::intrusive::detail::identity            \
+            >::type::TNAME type;                                           \
+   };                                                                      \
+//
+
+#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL)   \
+      typename INSTANTIATION_NS_PREFIX                                                       \
+         boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type                            \
+//
+
+#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \
+      typename INSTANTIATION_NS_PREFIX                                                          \
+         boost_intrusive_eval_default_type_ ## TNAME< T, TIMPL >::type                          \
+//
+
+}}}   //namespace boost::intrusive::detail
+
+#include 
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME pointer_to
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 1, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME static_cast_from
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 1, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME const_cast_from
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 1, ))
+#include BOOST_PP_ITERATE()
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME dynamic_cast_from
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 1, ))
+#include BOOST_PP_ITERATE()
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(element_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)
+
+//////////////////////
+//struct first_param
+//////////////////////
+
+template  struct first_param
+{  typedef void type;   };
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   template